Not sure how to include functions from multiple C files [duplicate] - c

Question

This question already has an answer here:
How to split a C program into multiple files?
(1 answer)
Closed 28 days ago.
I am not sure what is the best practice for including multiple c files. I was given two header files for an assignment, and am now required to create the corresponding c files.
Right now my issue is that I need to use functions defined in course.c in student.c, however, I am running into a linker issue that I am not sure how to resolve. The way I am currently including files is by creating multiple function definitions!
student.h
#include <stdbool.h>
#include <stdint.h>
struct course;
struct student;
struct student_id {
uint16_t sid_year;
uint32_t sid_serial;
};
struct student* student_create(struct student_id, bool grad_student);
void student_free(struct student*);
void student_take(struct student *s, struct course*, uint8_t grade);
int student_grade(struct student*, struct course*);
double student_passed_average(const struct student*);
bool student_promotable(const struct student*);
student.c
#include "student.h"
#include "course.c"
struct student
{
<Fields>
};
struct student* student_create(struct student_id id, bool grad_student)
{
<definition>
}
void student_free(struct student* s)
{
<definition>
}
void student_take(struct student *s, struct course* c, uint8_t grade)
{
<definition>
}
int student_grade(struct student* s, struct course* c)
{
<definition>
}
double student_passed_average(const struct student* s)
{
<definition>
}
bool student_promotable(const struct student* s)
{
<definition>
}
course.h
#include <stdint.h>
/** Course subjects. */
enum subject {
SUBJ_ENGI,
SUBJ_CIV,
SUBJ_ECE,
SUBJ_MECH,
SUBJ_ONAE,
SUBJ_PROC,
SUBJ_CHEM,
SUBJ_ENGL,
SUBJ_MATH,
SUBJ_PHYS,
};
struct course;
struct course* course_create(enum subject, uint16_t code);
enum subject course_subject(const struct course*);
uint16_t course_code(const struct course*);
void course_hold(struct course*);
void course_release(struct course*);
int course_refcount(const struct course*);
course.c
#include "course.h"
#include <stdio.h>
#include <stdlib.h>
struct course {
<fields>
};
struct course* course_create(enum subject sub, uint16_t code)
{
<definition>
}
enum subject course_subject(const struct course* c)
{
<definition>
}
uint16_t course_code(const struct course* c)
{
<definition>
}
void course_hold(struct course* c)
{
<definition>
}
void course_release(struct course* c)
{
<definition>
}
int course_refcount(const struct course* c)
{
<definition>
}
Which gives the following errors:
gcc *
multiple definition of `course_create'; ... first defined here ...
multiple definition of `course_subject'; ... first defined here ...
multiple definition of `course_code'; ... first defined here ...
multiple definition of `course_hold'; ... first defined here ...
multiple definition of `course_release'; ... first defined here ...
multiple definition of `ref_count'; ... first defined here ...
I am assuming this is an issue with me including course.c in student.c, but I need to include course.c to get the course structure definition. So I am wondering how I can go about retrieving the definition of struct course without using the line #include course.c

Answer 1

Do not #include source files. Move the structure definitions from the source files to the appropriate header files. Use include guards to avoid header files being processed more than once.
Below is a complete example that will compile cleanly with
gcc course.c student.c main.c
This is essentially an application of the answer to How to split a C program into multiple files?, but with functions and structures.
course.h:
#ifndef COURSE_H
#define COURSE_H
#include <stdint.h>
enum subject {
SUBJ_ENGI,
SUBJ_CIV,
SUBJ_ECE,
SUBJ_MECH,
SUBJ_ONAE,
SUBJ_PROC,
SUBJ_CHEM,
SUBJ_ENGL,
SUBJ_MATH,
SUBJ_PHYS,
};
struct course {
enum subject subject;
};
struct course *course_create(enum subject, uint16_t);
enum subject course_subject(const struct course *);
uint16_t course_code(const struct course *);
void course_hold(struct course *);
void course_release(struct course *);
int course_refcount(const struct course *);
#endif
student.h:
#ifndef STUDENT_H
#define STUDENT_H
#include <stdbool.h>
#include <stdint.h>
#include "course.h"
struct student {
char name[128];
};
struct student_id {
uint16_t sid_year;
uint32_t sid_serial;
};
struct student *student_create(struct student_id, bool);
void student_free(struct student *);
void student_take(struct student *, struct course *, uint8_t);
int student_grade(struct student *, struct course *);
double student_passed_average(const struct student *);
bool student_promotable(const struct student *);
#endif
course.c:
#include <stddef.h>
#include <stdint.h>
#include "course.h"
struct course *course_create(enum subject sub, uint16_t code)
{
return NULL;
}
enum subject course_subject(const struct course *c)
{
return SUBJ_ENGI;
}
uint16_t course_code(const struct course *c)
{
return 0;
}
void course_hold(struct course *c)
{
}
void course_release(struct course *c)
{
}
int course_refcount(const struct course *c)
{
return 0;
}
student.c:
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "course.h"
#include "student.h"
struct student *student_create(struct student_id id, bool grad_student)
{
return NULL;
}
void student_free(struct student *s)
{
}
void student_take(struct student *s, struct course *c, uint8_t grade)
{
}
int student_grade(struct student *s, struct course *c)
{
return 0;
}
double student_passed_average(const struct student *s)
{
return 0.0;
}
bool student_promotable(const struct student *s)
{
return false;
}
main.c:
#include <stdio.h>
#include "course.h"
#include "student.h"
int main(void)
{
struct student_id id = { 0, 0 };
struct student *stu = student_create(id, 0);
struct course *cour = course_create(SUBJ_MATH, 0);
puts("Hello world.");
}