How to match .c and .h properly? - c

Question

I have a C project and I really don't get how to manage .c and .h.
I've been using a method for years but now I have to create codes without any warnings, so I need to change the way I do it.
Here is how I'm doing it:
Each .c have a .h with the same name. Even main.c has a main.h.
In each .c, I include the matching .h, so I have only one include per .c.
In main.h, I include all the libraries I need, like stdio stdlib and so on. I also declare my enumerations and structures there.
Finally, in every other .h, I include the main.h which contains the structures, enums and libraries.
I understand that by doing that, I call main.h a lot of time, but I use the #ifndef and #define in every .h.
Also, I each .h contains the prototypes of the functions in their corresponding .c
How should I manage .c and .h?
I forgot to mention that the problem is that I get a warning for every single function: "implicit declaration of function"
Here is an example with four files :
main.c :
#include "main.h"
int main()
{
// code
}
int save(Player players[2], int currentPlayer)
{
// code
}
int load(Player players[2], int* currentPlayer)
{
// code
}
main.h :
#ifndef MAIN_H
#define MAIN_H
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <string.h>
#include <math.h>
typedef enum Direction Direction;
typedef enum Orientation Orientation;
typedef enum ShipType ShipType;
typedef enum CaseType CaseType;
typedef enum Status Status;
typedef enum PlayerType PlayerType;
enum Direction
{
Nord=0, Est=1, Sud=2, Ouest=3
};
enum Orientation
{
None=0, Horizontal=1, Vertical=2
};
enum ShipType
{
SousMarin=1, Destroyer=2, Croiseur=3, Cuirasse=4
};
enum CaseType
{
Undiscovered=0, Empty=1, Hit=2, Detected=3, Discovered=5
};
enum Status
{
Undamaged=0, Damaged=1, Drowned=2
};
enum PlayerType
{
Human=0, Computer=1
};
typedef struct Map Map;
typedef struct Ship Ship;
typedef struct Player Player;
struct Map
{
int width, height;
int* cases;
};
struct Ship
{
int x, y, length, firstShoot, color;
int hasBeenDiscovered;
Orientation orientation;
ShipType type;
Status status;
};
struct Player
{
int totalShips;
int activeShips;
Map map[2];
char lastMoves[5][128];
Ship* ships;
PlayerType type;
int shipcolor[4];
int shipNumber[4];
int color;
};
int save(Player players[2], int currentPlayer);
int load(Player players[2], int* currentPlayer);
#endif // MAIN_H
IA.c :
#include "IA.h"
int IA(Player* IA, Player* enemy)
{
// code
}
// And all my other functions
IA.h :
#ifndef IA_H
#define IA_H
#include "main.h"
int IA(Player* IA, Player* enemy);
void endIATurn(Player* IA);
int enemyShipDiscovered(Map map, int* x, int* y, int SousMarinSpecific);
Ship* bestFriendlyActiveShip(Ship* ships, int totalShips, int SousMarinSpecific);
int friendlyShipDiscovered(Ship** ship, Ship* ships, Map map, int totalShips, int SousMarinSpecific);
int hitShipButNotDrowned(Player* IA, Player enemy, int totalShips, int* x, int* y);
int hasAtLeastOneMoveableShip(Player player);
int hasUndiscoveredCases(Player player);
void getUndiscoveredCoordoonnees(Map map, int* x, int* y);
int findNextCaseToShootAt(Map map, Ship ship, int* a, int* b);
#endif // IA_H
All my other .h are like IA.h

Answer 1

For foo.h and foo.c:
Use foo.h to tell other source files about things that foo.c provides. So foo.h will declare functions that are (a) defined in foo.c and (b) called from other source files. It will also declare any types or other things that those functions need or that other source files need in able to be able to use the functions.
In foo.h, only use #include to include header files that foo.h itself needs.
In foo.c, use #include "foo.h". This has two purposes: (1) It declares things that foo.c may need, without having to duplicate those declarations in foo.c. (2) It ensures that foo.c is using the same declarations that other source files see when they include foo.h, so any conflicts between declarations in foo.h and definitions in foo.c will produce compiler warnings or error messages.
If foo.c needs any headers that foo.h, include them in foo.c, not foo.h. Similarly, if foo.c has any functions that it uses for itself but does not expect other source files to use, declare them only in foo.c. Keep things that are just for foo.c inside foo.c. Use foo.h only for exporting things to other source files.
If there are any types or other declarations used by your program generally:
Put them in a suitably named file (e.g., bar.h for types involving some bar concept) and include it. Largely, you can treat bar.h as a pair bar.h and bar.c described above except that bar.cis empty.
Generally, there is no reason to make a main.h. Usually, main.c uses things that other source files provide and does not provide things for other sources to use (except that main is called by the C run-time start-up code).

Answer 2

I suggest the following:
Divide your functions in different .c files as you already do. For every .c create a .h
In every .h insert its include guard:
Within the include guard, start by including the .h of the libraries you need to declare your functions or to define structs, e.g. #include <stdlib.h> if you use size_t parameters.
Within the include guard, insert the structs, enums, ... you need exported
Within the include guard, insert the function declarations.
In every .c start by including its corresponding .h, then include other libraries needed to implement your functions, then put in the definitions.
Don't make a main.h or common.h, unless you have extremely good reasons for it (I know this will be commented against, but everyone has its style).
In main.c include what you need. You'll be including much less than you think.