如何在另一个C文件中访问指向在一个C文件中声明的字符串文字的外部指针？

Question

I'm getting my sea legs with C, and I need a string literal which is discovered in a main function in one .c file to be accessible in an entirely different .c file.

What I've tried: I'm declaring a pointer to a string literal as extern in a header, defining it on one .c file, and trying to access the literal in a second .c file. Compilation is failing due to lack of definition in the second (accessing) file.

What I've got in a nutshell:

file1.h :

extern char *global;

file1.c :

#include "file1.h"

int main() {
     //some code
     extern char *global = some_struct->data;
     //more code
}

file2.c :

#include "file1.h"

int do_stuff() {
     //some code
     some_function(global);
     //more code
}

I expected this to compile, since global is declared in file1.h , defined in file1.c , and its value accessed in file2.c . Compilation of file2.c fails, however, for undefined variable.

If relevant, the main function in file1.c is always the first function run in the program.

Answer 1

in main

  extern char *global = some_struct->data; 

is wrong, if you want to assign global do :

     global = some_struct->data;

and some where at global scope you need to define global :

char *global;

So for instance main become :

#include "file1.h"

char *global;

int main() {
     //some code
     global = some_struct->data;
     //more code
}

Answer 2

You're close, but not quite there. The global variable must also be defined in the global scope, and you're running into the difference between declaration and definition (which are easy to get the wrong way round but the words don't matter as much as the idea). Normally, your statements that introduce a variable will both declare and define simultaneously, but not so with globals that are shared between modules like this:

In your file1.h , you are correctly declaring the char* variable in the global scope. Anyone who includes this file (eg file2.c ) will "see" that the variable with that name should exist and all modules will compile cleanly, and the extern keyword makes explicit that you are only declaring this to exist, not creating storage for it yet. That is what you want, because you don't want to accidentally create multiple conflicting global variables with this name. When the compiled modules are eventually linked together, the linker will look for the actual memory storage space set aside for the global and connect all the references up correctly.

But in your case, that won't happen correctly, because although you have declared to the world that this global exists, you haven't yet actually created storage for the variable!

You still need to do this in the global scope (outside the functions) in file1.h :

char * global; 

That creates the actual variable with the matching name to the extern declaration, and so the linker will be able to assemble your modules correctly.

So

#include "file1.h"

// Define global:
char * global;

int main() {
     // Assign a value to the global variable:
     global = some_struct->data;

     //more code
}

Note that you don't redeclare the extern or anything in this file, and you don't redefine the type of global inside main , because it already exists, and you can assign to it or look at its value. You also don't use the keyword extern here-- it is the "home" module for this variable.

Declaration and definition are generally just accomplished simultaneously, for example when you declare local variables within a function. Globals that are accessible from different modules rely on splitting the work into the two separate ideas so that both coworkers and the compiler and linker toolchain are not confused by your intentions.