Gleichnamige Funktion in anderer Datei aufrufen?

simonp

Hallo,

ich habe folgende Dateistruktur:

******* Datei1.h**********

int Hallo(int a, int b);

****************************

******* Datei1.cpp **********

int Hallo(int a, int b) {

   // macht irgendwas
}

****************************

******* Datei2.cpp **********

int Hallo(int a, int b) {

   // macht irgendwas
}

// weitere Funktionen

****************************

Die beiden *.cpp Datein liegen in unterschiedlichen Verzeichnissen (sind Teil eines grossen Projektes), werden aber beim make-Aufruf beide compiliert.

Bisher musste ich in den verschiedenen Funktionen von Datei2.cpp nur die Hallo-Funktion von Datei2.cpp aufrufen. Nun muss ich aber in Datei2.cpp auch die Hallo-Funktion von Datei1 aufrufen koennen. Ich kann in Datei2.cpp zwar #include "Pfad/Datei1.h" schreiben, aber dann gibt es ja zwei Funktionen mit dem selben Namen. Wie kann ich sie beim Aufruf unterscheiden? Die Funktionsnamen darf ich uebrigens nicht aendern, die sind im Projekt so vorgegeben und duerfen nicht angeruehrt werden...

Bitte um rasche Antworten, da das ganze ziemlich dringend und wichtig ist.

Vielen Dank im Voraus fuer Eure Hilfe!!!!

Simon

Hallo

namespace

chrische

Oder durch Verwendung von static. Das Schlüsselwort static auf Funktionen besagt, dass die Routine nur in der momentanen Übersetzungseinheit verfügbar ist.

Hierzu ein Beispiel... Würde man beide Funktionen als extern (standard für "globale" Funktionen) definieren, so würde sich der Linker beschweren ("multiple definition of `f()'").

// f1.cpp
#include <iostream>
using namespace std;

void f()
{
  cout << "void f(void) [f1.cpp]\n";
}

// f2.cpp
#include <iostream>
using namespace std;

static void f()
{
  cout << "void f(void) [f2.cpp]\n";
}

#include <iostream>
using namespace std;

void f();

int main()
{
  f();
}

Ausgabe: "void f(void) [f1.cpp]"

simonp

Ok, danke, mit namespace funktionierts:

******* Datei1.h********** 

namespace D1{
 int Hallo(int a, int b); 
}

**************************** 

******* Datei1.cpp ********** 

namespace D1{

 int Hallo(int a, int b) { 

    // macht irgendwas 
 } 

}
**************************** 

******* Datei2.cpp ********** 

int Hallo(int a, int b) { 

   // macht irgendwas 
} 

// weitere Funktionen 

void main() { 
     cout << D1::Hallo(1,2);
}

****************************

Nur ist die Lösung fuer mich nicht zulässig, da ich an Datei1.cpp und Datei1.h nichts ändern darf. Gibt es da einen workaround???

Bitte beachtet auch, dass es mehrere Dateien vom Typ Datei1.cpp gibt, also Datei1a.cpp, Datei1b.cpp, Datei1c.cpp usw. Diese haben alle die selbe Funktion "Hallo" und dürfen nicht geändert werden. In Datei2.cpp moechte ich sie alle includieren und dann die einzelnen Hallo-Funktionen aufrufen bzw. unterscheiden können...

Ist das irgendwie möglich??

Vielen Dank im Voraus!!!

Simon

PS: An Datei2.cpp darf ich ändern so viel ich will...

LordJaxom

Wenn Du
a) Die Dateien nicht ändern darfst
b) Jede dieser Hallo-Funktionen dieselbe Parameterliste hat (oder das ein C-Programm ist)
c) Keine dieser Dateien Namespaces benutzt

dann bekommst Du nichtmal alle Dateien in ein Executable gelinkt, da es multiple Symbols hageln wird.

Es sei denn Du meinst mit "inkludieren" tatsächlich dass Du c-Dateien in c-Dateien inkludieren willst. Das ist zwar ziemlich unschön und eigentlich macht sowas niemand, aber hier könnte das tatsächlich Dein Rettungsanker sein:

namespace D1a {
#include "Datei1a.cpp"
}

namespace D1b {
#include "Datei1b.cpp"
}

Bevor man zu solchen Mitteln greift sollte man allerdings darüber nachdenken der Projektleitung ein neues Design vorzuschlagen...