Calling #define from another file

Question

This is my code. I have file1.c and file2.c. I want to call the MESSAGE from file2.c but I can't seem to do it. I am newbie in C so I really don't know what to do. I researched already but, I can't seem to find a specific answer. Thankyou.

#define MESSAGE "this is message!"

helloworld(){
     printf("%s",MESSAGE);
     getch();
     }

---

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include "file2.c"

int main(void)
{
  helloworld();
}

Answer 1

There are a few misconceptions you have: First of all the concept of "calling" a macro. It's not possible, even if a macro looks like a function it's not a function and macros are not actually handled by the compiler. Instead macros are part of a separate language that is handled by a preprocessor, which takes the source file and modifies it to generate a translation unit that the compiler sees. (For more information about the difference phases of "compilation" see e.g. this reference.)

The preprocessor does this by basically doing a search-replace in the input source file: When it sees a macro "invocation" it simply replaces that with the "body" of the macro. When it sees an #include directive, it preprocesses the file and then puts the content in place of the directive.

So in your code, when the preprocessor sees the macro MESSAGE it is literally replaced by "this is message!". The actual compiler doesn't see MESSAGE at all, it only sees the string literal.

---

Another misconception is how you use the #include directive. You should not use it to include source files. Instead you compile the source files separately (which creates object files) and then link the generated object files together with whatever libraries are needed to form the final executable.

To solve the problem of macros (and other declarations) being available to all source files, you use header files. These are like source files, but only contains declarations and macros. You then include the header file in both source files, and both source files will know about the declarations and macros available in the header file.

So in your case you should have three files: The main source file, the source file containing the function, and a header file containing the macro and the function declaration (also known as a prototype). Something like

Header file, e.g. header.h:

// First an include guard (see e.g. https://en.wikipedia.org/wiki/Include_guard)
#ifndef HEADER_H
#define HEADER_H

// Define the macro, if it needs to be used by all source files
// including this header file
#define MESSAGE "this is message!"

// Declare a function prototype so it can be used from other
// source files
void helloworld();

#endif

Main source file, e.g. main.c:

// Include a system header file, to be able to use the `printf` function
#include <stdio.h>

// Include the header file containing common macros and declarations
#include "header.h"

int main(void)
{
    // Use the macro
    printf("From main, MESSAGE = %s\n", MESSAGE);

    // Call the function from the other file
    helloworld();
}

The other file, e.g. hello.c:

// Include a system header file, to be able to use the `printf` function
#include <stdio.h>

// Include the header file containing common macros and declarations
#include "header.h"

void helloworld(void)
{
    printf("Hello world!\n");
    printf("From helloworld, MESSAGE = %s\n", MESSAGE);
}

Now, if you use a command-line compiler like gcc or clang then you can simply build it all by doing e.g.

$ gcc -Wall main.c hello.c -o myhello

That command will take the two source files, main.c and hello.c and run the preprocessor and compiler on them to generate (temporary) object files. These object files are then linked together with the standard C library to form the program myhello (that's what the option -o does, names the output file).

You can then run myhello:

$ ./myhello
From main, MESSAGE = this is message!
Hello world!
From helloworld, MESSAGE = this is message!

Answer 2

You can write the files as below and compile the code as i mention in the following steps.

file1.h

#ifndef _FILE1_H
#define _FILE1_H

#define MESSAGE "this is message!"
extern void helloworld();

#endif

file1.c

#include "file1.h"

helloworld()
{
  printf("%s",MESSAGE);
  getch();
 }

file2.c

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include "file1.h"

int main(void)
{
  helloworld();
return 0;
}

For compiling,

gcc -Wall file1.c file2.c -o myprog

./myprog

Answer 3

Here is code try this:

In File1.C

#define FILE1_C
#include "file1.h"

helloworld()
{
  printf("%s",MESSAGE);
  getch();
 }

In File2.C

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include "file1.h"

int main(void)
{
  helloworld();
}

In File1.h

#ifdef FILE1_C
#define MESSAGE "this is message!"
#define EXTERN
#else
#define EXTERN extern
#endif


EXTERN helloword()

Answer 4

In your file1.c, MESSAGE is a preprocessor macro, which means the text MESSAGE will be replaced with the string "this is message!". It is not visible outside the file. This is because in C, translation units are the final inputs to the compiler, and thes translation units already have all of preprocessor macros replaced by the tokens of the corresponding argument.

If you want to have a common variable, you should declare the variable as extern in a .h header file, and then #include the file where you need to use it.

see Compiling multiple C files in a program

Answer 5

You have to put your #define in a .h file and include it in .c files where you want to use it.