error LNK2005

[barton4]

Hi,
wenn ich mein Programm unter Visual Studio kompilieren will kommen folgender Fehler:

Fehler	13	error LNK2005: "char const register_addr0" (?register_addr0@@3DB) ist bereits in main.obj definiert.	processor.lib

mein Programm besteht aus:
Processor.h
Processor.cpp
und
mainprog.cpp

wobei in der mainproc.cpp die Processor.h "includiert " wird

in der Processor.h sind bestimmte Konstanten deklariert und zugewiesen
wie z.B:

extern const char* name_register_addr0		= "ad0";
extern const char* name_register_addr1		= "ad1";

nun hab ich die Vermutung das er die Konstanten in mainproc.cpp kompiliert und dann noch mal in Processoer.h.

Ich habe gehofft das der "extern" Befehl da behebt, aber die Fehlermeldungen sind gleich geblieben.


gibt es da eine Möglichkeit das zu umgehen? ansonsten müsste ich #define benutzen, da findet dann aber wieder keine Typenprüfung statt bzw Typenlos.

Der g++ unter Linux spuckt auch errors aus

martin@turion64:~/Desktop/Downloads/test$ g++ Processor.o Memory.o main.o
main.o:(.rodata+0x13): multiple definition of `register_akku'
Processor.o:(.rodata+0x4): first defined here
main.o:(.rodata+0x14): multiple definition of `register_b'
Processor.o:(.rodata+0x5): first defined here
main.o:(.rodata+0x15): multiple definition of `register_c'
Processor.o:(.rodata+0x6): first defined here
main.o:(.rodata+0x16): multiple definition of `register_d'
Processor.o:(.rodata+0x7): first defined here
main.o:(.rodata+0x17): multiple definition of `register_e'
Processor.o:(.rodata+0x8): first defined here
main.o:(.rodata+0x18): multiple definition of `register_f'
Processor.o:(.rodata+0x9): first defined here
main.o:(.rodata+0x19): multiple definition of `register_addr0'
Processor.o:(.rodata+0xa): first defined here
main.o:(.rodata+0x1a): multiple definition of `register_addr1'
Processor.o:(.rodata+0xb): first defined here
main.o:(.rodata+0x1b): multiple definition of `register_noreg'
Processor.o:(.rodata+0xc): first defined here
main.o:(.data+0x0): multiple definition of `name_register_akku'
Processor.o:(.data+0x0): first defined here
main.o:(.data+0x8): multiple definition of `name_register_b'
Processor.o:(.data+0x8): first defined here
main.o:(.data+0x10): multiple definition of `name_register_c'
Processor.o:(.data+0x10): first defined here
main.o:(.data+0x18): multiple definition of `name_register_d'
Processor.o:(.data+0x18): first defined here

[jeebee]

mach in dein Header-File ein

#ifndef __PROCESSOR_H
#define __PROCESSOR_H

und ans Ende ein

#endif

Dann wird der Header-Code nur höchstens einmal inkludiert.

[ContainerDriver]

Hallo.

Also laut meinem C-Buch wird eine Variable mit dem Attribut extern versehen, wenn man sie deklarieren, aber nicht definieren will. Die Definition kann dann (einmalig) an einer anderen Stelle erfolgen. Da du der Variable gleichzeitig einen Wert zuweist, willst du sie auch definieren, was dann aber mehrmals in verschiedenen Quelldateien steht.

Wie du dein Vorhaben realisieren kannst, fällt mir gerade nicht ein, aber mit extern geht es so wohl nicht. Du könntest höchstens die Initialisierung aus dem Header rauswerfen und z.B. in mainprog.cpp einfügen. Ich bezweifle aber, dass das die beste Lösung ist.

Processor.h
extern const char* name_register_addr0;
extern const char* name_register_addr1;

mainprog.c
const char* name_register_addr0="ad0";
const char* name_register_addr1="ad1";

Gruß, Florian

[Boron]

Einfach zu merken ist Folgendes: In einer Header stehen nur Deklarationen!
Das sollte man als Dogma verstehen. In Verbindung mit den "Include Guards", wie von jeebee erwähnt, sind dann Mehrfachdefinitionen nicht mehr möglich.

Anschließend, kann die Headerdatei überall inkludiert werden, wo die über extern bekannt gemachten Variablen und Funktionen benötigt werden.

Die Definition von Funktionen und Variablen erfolgt dann in einer c-Datei.

Und das ist dann die beste (und sinnvollste) Lösung .

Ach, und eins noch:
Man darf Variablen (und Funktionsnamen auch ohne _ benennen). Leserlicher wäre z.B. NameRegisterAddr0 und NameRegisterAddr1. Die Unterstriche reißen den Namen immer so auseinander. Aber das ist mehr eine Philosophie und führt wie Programmierrichtlinien mit Namenskonventionen zu Religionskriegen und endlosen Diskussionen ohne Ergebnis.

[barton4]

Hallo.

Also laut meinem C-Buch wird eine Variable mit dem Attribut extern versehen, wenn man sie deklarieren, aber nicht definieren will. Die Definition kann dann (einmalig) an einer anderen Stelle erfolgen. Da du der Variable gleichzeitig einen Wert zuweist, willst du sie auch definieren, was dann aber mehrmals in verschiedenen Quelldateien steht.

Wie du dein Vorhaben realisieren kannst, fällt mir gerade nicht ein, aber mit extern geht es so wohl nicht. Du könntest höchstens die Initialisierung aus dem Header rauswerfen und z.B. in mainprog.cpp einfügen. Ich bezweifle aber, dass das die beste Lösung ist.

Processor.h
extern const char* name_register_addr0;
extern const char* name_register_addr1;

mainprog.c
const char* name_register_addr0="ad0";
const char* name_register_addr1="ad1";

Gruß, Florian

danke für die schnelle Hilfe.
Hab es jetzt so gemacht wie es oben steht. Das "Dogma" das man in der .h nichts zuweist kenn ich gar nicht, jedenfalls nicht bei Variablen nur bei Funktionen.
Vieleicht werd ich auch wieder #define benutzen weil das auch ne menge schreibarbeit spart. So muss man erst alles in der *.h Datei zu deklarieren und dann nochmal in der *.cpp Datei zuzuweisen.

@Boron, Unterstriche müssen sein, ohne gehts gar nicht :-)

Gruß

[locus vivendi]

n der Processor.h sind bestimmte Konstanten deklariert und zugewiesen
wie z.B:

extern const char* name_register_addr0          = "ad0";
extern const char* name_register_addr1          = "ad1";

nun hab ich die Vermutung das er die Konstanten in mainproc.cpp kompiliert und dann noch mal in Processoer.h.

Hier steckt ein Missverständnis drin: Du schreibst, dass es sich um Konstanten handeln soll. Aber das stimmt nicht. Es handelt sich um echte Variablen, denen du z.B. auch einen neuen Wert zuweisen kannst, wie z.B. in

name_register_addr0 = "Irgend ein Quatsch.";

Wenn du eine tatsächlich Konstante deklarieren möchtest, dann kannst du das so tun:

 char const* const name_register_addr0 = "ad0";

Das erste "const" habe ich dabei nur umgestellt. Aber das zweite "const" ist wesentlich. Auf diese Weise würden deine Linkerfehler verschwinden.

[barton4]

so wie ich das vertehe ist das erste "const" für einen Konstanten Pointer und das zweite "const" für die entsprechende Variable auf die der Pointer zeigt?

Aber hab es gerade ausprobiert und es geht tatsächlich, kannst du noch kurz erklären wie so das so ist, bzw wie dann der Linkerfehler verschwindet?

Vielen Dank

Gruss Martin

[locus vivendi]

so wie ich das vertehe ist das erste "const" für einen Konstanten Pointer und das zweite "const" für die entsprechende Variable auf die der Pointer zeigt?

Eher andersrum. Das erste const, also das links, bedeutet, dass die Objekte auf die der Zeiger zeigen kann sozusagen "const" sind. Aber das ist nicht schön ausgedrückt. Besser sagt man, durch diesen Zeiger sollen die Objekte nicht verändert werden. Das zweite const (das rechts) hingegen macht die deklarierte Variable zu einer echten Konstante.

Es gibt für const in Deklarationen eine einfach Regel, die lautet: "Das Wort const bezieht sich auf das was links von ihm steht."
Zu dieser Regel gibt es aber eine Ausnahme die du ursprünglich verwendet hast, in dem du das const ganz außen links gesetzt hast. Aber mehr will ich hier nicht erklären, das kann Dan Saks besser als ich:
http://www.dansaks.com/articles/1999...vs T const.pdf
(Das sind wirklich Leerzeichen in der URL, evtl durch %20 oder so ersetzen.)

Weil in diesem Thread auch Kommentare waren, die sich auf C bezogen, du aber einen C++ Quelltext hast, möchte ich hier auch noch mal darauf hinweisen, dass sich die Bedeutung von mit const deklarierten globalen Variablen zwischen C und C++ unterscheidet. Mehr dazu hier:
http://david.tribble.com/text/cdiffs...-const-linkage