I'm new to C programming and encounter this question:
Three files: main.c, foo.h, foo.c are in the same directory.
main.c:
#include <stdio.h>
#include "foo.h"
int main(){
printf("%d",func(1));
}
foo.h declares function func:
int func(int);
foo.c defines function func:
#include "foo.h"
int func(int a){
return a+1;
}
This code works as expected, but when I rename the definition file foo.c into something else, say bar.c, then main.c throw an error during compilation saying:
LLVM ERROR: Program used external function _func which could not be resolved!
I know that the definition file doesn't need to have the same name as the header file. Why the linker can't find the appropriate definition after I renamed foo.c into bar.c?
More generally, how does the linker search for function definition? Search every .c files in the same directory, one by one? Only search for definition in the .c file, which has the same file name as header file?
EDIT:
I was using code-runner IDE on MacBook, don't know how the IDE actually compiles the source files.
Add the file name in the compilation command:
$ gcc -o main main.c foo.c && ./main
^^^^^
Related
I have 2 files:
a.c
b.c
a.c:
#include <stdio.h>
#include "b.c"
int main()
{
printf("%s", B_VAR);
return 0;
}
b.c:
static char B_VAR[] = "Hello world!\n";
Compile and run:
jonathan:~/code/staticDemo$ gcc a.c -o test
jonathan:~/code/staticDemo$ ./test
Hello world!
I was under the impression that static would make B_VAR limitted to b.c only, yet this seems to work.
It is true that the static keyword makes variables only visible to a single C file. However, in a.c you are including b.c meaning that it is not compiled and linked with a.c, but instead copied into a.c.
The C preprocessor copies one file to another when including, and the preprocessor is executed before the file is compiled.
So this is the effective code to be compiled (generated with GCC using the -e flag, and excluding the <stdio.h> definitions):
# 2 "a.c" 2
# 1 "./b.c" 1
static char B_VAR[] = "Hello world!\n";
# 3 "a.c" 2
int main()
{
printf("%s", B_VAR);
return 0;
}
And this means that B_VAR is accessible in a.c because it really is in a.c.
If you instead compiled each separately and linked them together for the final executable, B_VAR would not be accessible.
Example (-c means to only preprocess and compile, but don't link):
gcc -c a.c -o a.o
(GCC fails with use of undeclared identifier 'B_VAR')
gcc -c b.c -o b.o
gcc a.o b.o -o test
./test
Hope this helped.
The static keyword as used there makes a variable local to a "translation unit", not a file. An #include directive pulls all the contents of the named file into the current translation unit. So yes, B_VAR is accessible.
To create a program using multiple translation units, you would skip the #include "b.c" and instead give both source files to the compiler driver:
$ gcc a.c b.c -o test
Normal practice is to never #include a source file, only header files. When a project gets more complicated, including a source file via multiple other files will cause multiple definition errors.
The files a.c and b.c are not compiled independently of each other. You're including b.c inside of a.c. So what the compiler sees after preprocessing for a.c looks like this:
// contents of stdio.h
static char B_VAR[] = "Hello world!\n";
int main()
{
printf("%s", B_VAR);
return 0;
}
So what static actually does it make a variable / function local to the compliation unit in which is resides which may consist of one or more source files that are included together.
Had you removed the include and compiled the two files separately, then you would see an error.
I have a test.c file which contains main() function and some test cases and it cannot be modified it(such as adding "include *.h"). Then I have a foo.c file which contains some functions(no main() function). These functions will be tested through test cases in test.c file. What I'm going to do is use foo.c as a library and link it to test.c file. And here is the simple code.
test.c
//cannot modify
int main(){
...
bar();
...
}
foo.c
#include "foo.h" //I will explain this below.
int bar(){
...
}
I'm trying to implement an interface using .h file, such as
foo.h
#ifndef _FOO_H_
#define _FOO_H_
extern int bar();
#endif
Then using cmd line
gcc -c foo.c
gcc -o output test.c foo.o
./output
You may guess the result. There is a warning that "implicit declaration of function 'bar' is invalid in C99 [-Wimplicit-function-declaration]". And the test.c file cannot run correctly.
Could someone help me about this? Thank you so much!
Your problem is:
test.c has a call to bar() in it.
test.c doesn't have any declaration for bar, nor does it have an #include for a .h file that declares bar.
You are not allowed to change test.c in any way to add either a declaration or an #include.
This is a hard problem. The C language requires there be a prototype/declaration for bar in test.c! It can be written directly in the test.c file (write extern int bar(); before you call it), or the declaration can come in from another file with an #include statement, but you must have it.
Luckily, GCC has a way to force an #include statement into a file while it's compiling the file. You don't have to change test.c in order to make it start with #include "foo.h". This will solve your problem:
gcc -c -include foo.h test.c
You need to include the declaration of bar in the test.c file:
#include "foo.h"
So that the compiler have the prototype in the translation unit, of test.c.
I have this block of code. I have to move the given function display_name() into another .c file, compile it, and find the error that was caused due to the migration of the function and correct it by creating a header file with a prototype. How can I do it?
#include <stdio.h>
#include <string.h>
#include <ctype.h>
char student[]="Rasmus Lerdorf";
void display_name()
{
printf("Student Name : %s",student);
}
int main()
{
display_name();
}
these are the changes i made but again i still get an error in the main.cpp. it doesnt allow me to include the displayname.h file.
displayname.h
void display_name(void);
displayname.cpp
#include <stdio.h>
#include "displayname.h"
char student[] = "Rasmus Lerdorf";
void display_name()
{
printf("Student Name : %s", student);
}
main.cpp
#include <stdio.h>
#include "displayname.h"
int main()
{
display_name();
}
errors are:
3 IntelliSense: identifier "display_name" is undefined c:\Users\konstantinos\Desktop\main\main.cpp 7 2 Cproject
2 IntelliSense: cannot open source file "displayname.h" c:\Users\konstantinos\Desktop\main\main.cpp 2 1 Cproject
Error 1 error C1083: Cannot open include file: 'displayname.h': No such file or directory c:\users\konstantinos\desktop\main\main.cpp 2 1 Cproject
Prototype functions work like this: for each set of functions that you write (except main) you need a definition and an implementation. Definitions are usually stored in header files (extension .h) whereas implementations are stored in source files (extension .c).
Here is an example of how you could arrange your code to solve your problem.
Definition: display.h
// This file contains the definitions of the functions which you want to call from another file
void display_name(void);
Implementation: display.c
#include "display.h"
#include <stdio.h>
static char student[]="Rasmus Lerdorf";
void display_name()
{ printf("Student Name : %s",student);
}
With both the definition defined and the desired implemented, now you can call the function from your main source file.
Implementation: main.c
#include "display.h"
#include <stdio.h>
int main()
{
display_name();
}
This is how you link together a prototype of a function and the implementation of a function. You can expand this by adding more prototypes to display.h, implementing those prototyped functions in display.c, and then calling them throughout your code.
To build, both of these .c files must be included in your build phase. If you build from the command line, you need to do something like this (I'm assuming that your compiler is gcc):
cc display.c main.c -o program
Hope this helps.
Your header file, let's call it displayname.h should contain the declaration:
void display_name(void);
It's usually also best to create an include guard, which avoids causing problems if a header is included more than once:
#ifndef DISPLAYNAME_H
#define DISPLAYNAME_H
void display_name(void);
#endif /* DISPLAYNAME_H */
Then, in your displayname.c, you would include that header plus any others needed by the function, and define your constant and the function:
#include <stdio.h>
#include "displayname.h"
char student[]="Rasmus Lerdorf";
void display_name()
{
printf("Student Name : %s",student);
}
And in your main.c, you would also include that header:
#include "displayname.h"
int main()
{
display_name();
return 0;
}
I don't know what compiler you are using, but if you're on a Unix-like system (Linux, Mac OS X, or something like msys or Cygwin under Windows), you would compile and link them as follows (you can replace cc with your specific compiler, such as gcc or clang, though on most systems cc should exist and point to the default compiler for that system):
cc -c -o displayname.o displayname.c
cc -c -o main.o main.c
cc -o myprogram main.o displayname.o
You could also abbreviate this as:
cc -o myprogram main.c displayname.c
I also recommend, when you are learning, to use the -Wall -Wextra -Werror flags, to give you as many warnings as possible, and not allow compilation to proceed if there are any warnings. To make this more convenient, so you don't have to type the whole command every time, you can define a simple Makefile; the following uses GNU make syntax, if you don't have GNU make let me know and I'll edit it to use a more portable syntax:
CFLAGS=-Wall -Wextra -Werror
myprogram: main.o displayname.o
cc -o $# $^
%.o: %.c
cc -c $(CFLAGS) -o $# $<
main.o: displayname.h
displayname.o: displayname.h
If you have this set up, you can just type make and it will recompile everything that it needs to.
edit: I see now from your comments that you are using Visual Studio, so the above tips on how to compile and link using cc and make are not relevant to you. It has been too long since I have used Visual Studio to walk you through that myself, but Microsoft has a reasonable walkthrough of how to create and build a project that you can follow. The tutorial is for C++, but it should work similarly for C, just keep in mind that files should be named .c if they are written in C, and only .cpp if they are written in C++.
i did what you said! i created the 3 specific files displayname.h for the prototype , displayname.cpp in which the function display_name() stays and main.cpp in which i call the function display_name(). the problem again is that when i include the file displayname.h in the displayname.cpp it works fine, but when i include it in the main.cpp i have an underline error in the include. what is wrong?
Firstly, I'd like to thanks you in advance for the time you'll take to help me out. If I may suggest you, you can try reproduce my problem. Don't try to read the makefiles if you don't feel it'll help you to understand my problem.
Also, I'd like to point out the fact I did a lot of researches and I don't have find any solution.
My Environment
Eclipse (with CDT)
Windows (cygwin) (but I also tried on Ubuntu)
I want to use my own (shared) library in a project.
My Setup
My Shared Library
mylib.h
#ifndef MYLIB_H_
#define MYLIB_H_
extern int foo();
#endif /* MYLIB_H_ */
mylib.c
#include "mylib.h"
extern int foo() {
return 1;
}
My Project
I added my library as a reference :
Project Properties - C/C Generals - Paths and Symbols - References (tab) - Check off mylib (Active)
foo.c
#include <stdlib.h>
int main(int argc, char **argv) {
return foo();
}
Problem
I'm getting implicit declaration of function 'foo' [-Wimplicit-function-declaration] warning when I build my project. This warning only occurs when I build my project while my library project has nothing to build (because it hasn't been modified since the last build).
Console output
Info: Internal Builder is used for build
gcc -std=c99 "-ID:\\Users\\cmourgeo\\maximo workspace\\mylib" -O0 -g3 -Wall -c -fmessage-length=0 -o "src\\uselib.o" "..\\src\\uselib.c"
..\src\uselib.c: In function 'main':
..\src\uselib.c:12:2: warning: implicit declaration of function 'foo' [-Wimplicit-function-declaration]
return foo();
^
gcc "-LD:\\Users\\cmourgeo\\maximo workspace\\mylib\\Debug" -o uselib.exe "src\\uselib.o" -lmylib
Should I provide eclipse my own makefiles ? (under C/C++ / Builder Settings)
Solution
I had to include my header in foo.c
#include "../src/mylib.h"
The path is kind of weird because of my projects structures :
myproject
src
foo.c
mylib
src
mylib.c
mylib.h
Thanks to user590028 for helping me getting through that !
In foo.c you forgot to include the mylib.h header
/* foo.c */
#include <stdlib.h>
#include "mylib.h" /* <-- include this line */
int main(int argc, char **argv) {
return foo();
}
You should include
extern int foo();
in foo.c
then you can compile:
gcc -c mylib.c
gcc mylib.o foo.c -o foo
and execute:
./foo
As you are using eclipse, maybe it compiles corret after including the extern line and it's not needed to compile manually.
Every time I compile I get the following error message:
Undefined reference to ( function name )
Let's say I have three files: Main.c, printhello.h, printhello.c. Main.c calls function print_hello(), which returns "Hello World". The function is defined in printhello.c.
Now, here's the following code of printhello.h:
#ifndef PRINTHELLO_H
#define PRINTHELLO_H
void print_hello();
#endif
I am sure this code is fine. I still don't know why is it giving me the error, though. Can you help me?
Undefined references are the linker errors. Are you compiling and linking all the source files ? Since the main.c calls print_hello(), linker should see the definition of it.
gcc Main.c printhello.c -o a.out
The error is, I think, a linker error rather than a compiler error; it is trying to tell you that you've not provided all the functions that are needed to make a complete program.
You need to compile the program like this:
gcc -o printhello Main.c printhello.c
This assumes that your file Main.c is something like:
#include "printhello.h"
int main(void)
{
print_hello();
return 0;
}
and that your file printhello.c is something like:
#include "printhello.h"
#include <stdio.h>
void print_hello(void)
{
puts("Hello World");
}
Your declaration in printhello.h should be:
void print_hello(void);
This explicitly says that the function takes no parameters. The declaration with the empty brackets means "there is a function print_hello() which returns no value and takes an indeterminate (but not variadic) list of arguments", which is quite different. In particular, you could call print_hello() with any number of arguments and the compiler could not reject the program.
Note that C++ treats the empty argument list the same as void print_hello(void); (so it would ensure that calls to print_hello() include no arguments), but C++ is not the same as C.
Another way to do it is to explicitly build object files for the printhello:
gcc -c printhello.c -o printhello.o
gcc -o Main main.c printhello.o
This has the added benefit of allowing other programs to use the print_hello method
It seems that the error is from the linker and not the compiler. You need to compile and link both the source files. I think what you are doing is simply including the header file in Main.c and you are not compiling the printhello.c
You need to :
gcc Main.c printhello.c -o myprog
or
construct the object files first
gcc -c printhello.c
gcc -c Main.c
then link them
gcc Main.o printhello.o