1

As I was going through a huge source code, I came across some files where there is only one function declared in, let's say, "code.h" but in "code.c" there are many functions declared and defined.

What is the exact use of declaring and defining functions in .c files ? How can we access one of those functions in a source file from other source file ?

It would be helpful if anyone can provide an example. Thanks

karra
  • 45
  • 1
  • 10

4 Answers4

3

Splitting a complex routine in multiple smaller routines might make the code easier to understand and also would allow you to follow the single responsibility principle (What is an example of the Single Responsibility Principle?). By declaring and defining them only in a .c file (and declaring them static), you can hide the internal details from users.

If you, for instance, create a library, then your header could only show the public functions you'd like your users to use.

So only put your functions in a header if you'd like those functions available to anyone who includes the header.

If you'd like to keep a function internal to your .c file, seriously consider adding the static keyword as well: what is the advantage of static function?

---edit---

How can we access one of those functions in a source file from other source file ?

If the function isn't static, you could technically declare it anywhere* you'd like and use it there as well. Though, by the above argument, this would be bad practice.

Example:

a.c

int secret_a(int x)
{
    return x+1;
}

main.c

#include <stdio.h>

//access a secret function from a.c
int secret_a(int);

int main()
{
    printf("secret_a(3) gives: %d\n", secret_a(3));
    return 0;
}
  • (*) anywhere allowed by the C language
Jonathan Leffler
  • 730,956
  • 141
  • 904
  • 1,278
Lanting
  • 3,060
  • 12
  • 28
0

How can we access one of those functions in a source file from other source file ?

That is the whole idea with defining some functions in the header, and some only in the c-file.

The functions defined in the header, can be called by other source files. The functions only defined in the source file, can be hidden - it is a usual practice to mark functions, only declared in a source file, as static. That makes their visibility limited to the file-scope (only code inside the same file can 'see' the functions).

Morten Jensen
  • 5,818
  • 3
  • 43
  • 55
0

The reason why this is done is to split the code into a more cleaner and sorted format so that functions concerning a particular operation can be grouped together in to one file and then called from other file. NOTE: this is not mandatory to do but a good programming practice.

Now there are two ways to do it : 1. including the files 2. Declaring the function as extern and then linking them at linking time.

1. Including the file is the method that you are probably seeing in your code at hand. Functions are defined in one file and that file is included using #include"filename.[h/c]" and then calling the function as it were declared in the given file.

file_to_include.c

void my_func()
{
printf("Hello!\n");
}

file_that_include.c

#include<stdio.h>
#include"file_to_include.c"
int main()
{
 my_func();
 return 0;
 }

to compile you just do 

gcc file_that_include.c
  1. using extern you can do the same but with out using the #include directive

file_to_include.c

void my_func()
{
printf("Hello!\n");
}

file_that_include.c

#include<stdio.h>

extern void my_func();
int main()
{
 my_func();
 return 0;
 }

In this case while compiling you need to provide both files to the compiler 

gcc file_that_include.c file_to_include.c
yashC
  • 887
  • 7
  • 20
0

I would suggest reading up on the "extern" keyword.

From what I can understand in your question you have two files - "code.h" and "code.c". However, "code.h" only declares certain functions in "code.c":

code.h

int func1();
int func2();

code.c

int func1()
{
  return 1;
}

int func2()
{ 
  return 2;
}

int func3()
{ 
  return 3;
}

main.c

#include "stdio.h"
#include "code.h"

extern int func3();

int main()
{
  printf("%d ", func1());
  printf("%d ", func2());
  printf("%d ", func3());
}

Compiling using gcc:

gcc main.c code.c

yields:

main.c: In function ‘main’:
main.c:10:17: warning: implicit declaration of function ‘func3’ [-Wimplicit-function-declaration]
   printf("%d ", func3());

and when executed:

1 2 3

The "extern" keyword basically tells the compiler "there is a definition for a function with this declaration" for compiling. During linking the linker will find the definition, and link to it.

This is however a clumsy way of doing it, since the caller ("main.c") needs to know what is going on in "code.c", and continually add more extern declaration, etc. etc.

So rather include functions you which to have global scope in "code.h". If there are functions in "code.c" which od not have global scope, consider making them "static".

Some more reading: Effects of the extern keyword on C functions

BlinkFan
  • 1
  • 1