Extern pointers

Am i doing this right. This is what i have got.

Main.c

Code:

---

for(i=0; i<10; i++)
    {
        printf("Data 1 - %d\n", NODE[i].data1);
        printf("Data 2 - %d", NODE[i].data2);
        printf("\n-----------\n");
    }

---

Lib.c

Code:

---

NODE = malloc( sizeof(struct node) * 10 );

---

Struct.h

Code:

---

struct node
{
    int data1;
    int data2;
};
extern struct node *NODE;

---

I get undefined reference on main.c and perhaps in Lib.c. Does extern works for pointers?

ssharish

Yes, that should work just fine [at least as long as "Lib.c" isn't a DLL].

--
Mats

AFAIK, if you're just using the include directives, there's no need to do extern.

Quote:

---

Originally Posted by IceDane

AFAIK, if you're just using the include directives, there's no need to do extern.

---

The compiler itself doesn't know if the "source" is part of an include file or not. For function declarations, "extern" is not important, but for variables you do need an "extern" to tell the compiler NOT to generate the space for the variable, but let that be resolved at the linker stage.

@ssharish: You do need a variable definition too, something like

Code:

---

struct node *NODE;

---

This should go in either of main or lib.c [or in a "globals.c" where you would have ALL of the global variables.

--
Mats

Hey Map, that worked. Took out the extern keyword in my .h file and included extern on my .c file. Everything worked fine.

Do basically i was misplacing things incorrectly.

ssharish

Eh? But it's safe to use extern in headers.
You just need to make sure there's an actual definition somewhere.

You want extern in your headers, and the source in your .c files, because the headers might be included more than once.

The thing is, you can have any number of extern declarations of a variable before you declare the variable itself. This compiles and runs with no worries:

Code:

---

#include <stdio.h>

extern int x;
extern int x;
extern int x;
int x;

int main() {
    x = 3;
    printf("&#37;i\n", x);
    return 0;
}

---

So you can have a header file like this

Code:

---

/* header.h */
extern int x;

---

because it works in code that doesn't declare the variable

Code:

---

#include <stdio.h>
#include "header.h"

void print(void) {
    printf("%i\n", x);
}

---

as well as in code that does:

Code:

---

#include "header.h"

int x;

int main() {
    x = 3;
    print();
    return 0;
}

---

Just to summarize: You should NOT remove extern in your header-file, you should have ONE .c file that contains a "without extern" definition of the variable.

--
Mats

Wow, thanks a lot. That makes things clear. I always had this confusion on how to use extern variable. Perhaps whenever I use them something goes wrong somewhere lol. I think I am on right track now. Just to make things clear. Here is what I have learnt from this thread

The extern variables are supposed to be declared in the header files. But to reference those extern variable in the .c file, the variable have to be redeclared again in the .c file some where.

@DWK - The first sample code which you posted made me to think a bit. But I couldn't answer my question by myself. Shouldn’t there be a clash if you have a variable with the same name multiple times. But in your case it tents to compile fine. Which mean that its been declared just once in the symbol table. How is that?

Thanks once again for all of you, for just a great help. You made a person happy :)

ssharish

An extern declaration does not create a new symbol; it just says "FYI, there is an int x somewhere; we'll find it later." This way the compiler knows the type of all the symbols, and can generate most of the right code; the linker's job is then to match this mystery variable with its actual declaration in a file.

The extern keyword is just used to tell the compiler that there is some variable by a name of that type. It does not actually allocate space for it, so you can have as many statements of extern as you want, as long as there is a corresponding non-extern statement in one file. That's why header files don't get multiple definition errors, because even though they are included in more that one source file, they are externs, so they don't actully allocate space. They just inform the compiler of the type and the name. The compiler then encodes this information into the object file created form each source file, and then the linker checks all of those references to the same name and type and "links" them together so that they refer to the same variable. However, if the linker finds out that there is more than one non-extern statement that has the same name, then that's when the linker gives a multiple definition error.