Czy można uniknąć powtarzania nazwy klasy w pliku implementacji?

Question

Czy istnieje sposób, aby uniknąć powtarzania Graph:: w pliku implementacji, a mimo to podzielić klasę na nagłówek + implementację? Takich jak:

nagłówku pliku: Plik

#ifndef Graph_H 
#define Graph_H 

class Graph { 
public: 
    Graph(int n); 
    void printGraph(); 
    void addEdge(); 
    void removeEdge(); 
}; 

#endif 

Realizacja:

Graph::Graph(int n){} 
void Graph::printGraph(){} 
void Graph::addEdge(){} 
void Graph::removeEdge(){} 

Answer 1

Zgaduję, że ma to na celu uniknięcie "niepotrzebnego pisania". Niestety nie ma sposobu, aby pozbyć się zasięgu (jak wiele innych odpowiedzi ci powiedziała) jednak to, co robię osobiście, to klasa zdefiniowana we wszystkich moich prototypach funkcji w ładnych wierszach, a następnie skopiuj/wklej do pliku implementacji, a następnie ctrl-c your ClassName :: na tablicy klipów i uruchom linię za pomocą ctrl-v. .

Answer 2

Jeśli chcesz uniknąć wpisując "Graph ::" przed printGraph, addEdge itd., wtedy odpowiedź brzmi "nie", niestety. Funkcja "partial class" podobna do C# nie jest dostępna w C++, a nazwa dowolnej klasy (np. "Graph") nie jest przestrzenią nazw, jest zasięgiem.

Answer 3

Nie, nie da się tego uniknąć. W przeciwnym razie, skąd wiadomo, że dana definicja funkcji dotyczy funkcji klasy lub funkcji statycznej?

Answer 4

Nie, nie ma. Nie bezpośrednio. Możesz użyć sztuczek preprocesora, ale nie rób tego.

#define IMPL Graph:: 

IMPL Graph(int n){} 
void IMPL printGraph(){} 
void IMPL addEdge(){} 
void IMPL removeEdge(){} 

Ponadto, nie należy nawet chcą zrobić. Jaki jest sens. Poza tym, że jest to reguła C++, daje ci znać, że faktycznie implementujesz funkcję członka.

Answer 5

Jeśli pytasz, czy możesz zdefiniować funkcję składową, taką jak Graph::printGraph bez określania kwalifikacji do klasy, wówczas odpowiedź brzmi "nie", a nie tak, jak chcesz. Nie jest to możliwe w C++:

plik realizacja:

void printEdge(){}; 

Powyższy skompiluje dobrze, ale to nie będzie robić, co chcesz. Nie zdefiniuje funkcji członka o tej samej nazwie w klasie Graph. Zamiast tego zadeklaruje i zdefiniuje nową bezpłatną funkcję o nazwie printEdge.

Jest to dobre i właściwe, jeśli z twojego punktu widzenia trochę bólu, ponieważ po prostu może chcesz dwie funkcje o tej samej nazwie, ale w różnych zakresach. Rozważ:

// Header File 
class A 
{ 
    void foo(); 
}; 

class B 
{ 
    void foo(); 
}; 

void foo(); 

// Implementation File 
void foo() 
{ 
} 

Do jakiego zakresu należy się stosować? C++ nie ogranicza możliwości posiadania różnych funkcji o tych samych nazwach w różnych zakresach, więc musisz powiedzieć kompilatorowi, jaką funkcję definiujesz.

Answer 6

EDIT: misread pytanie :(to byłaby odpowiedź na pytanie, czy można podzielić nagłówka plików przykro

Prosta odpowiedź: można podzielić C++ - plik, ale nie można podzielić do plików nagłówkowych.

Powód jest dość prosty. Ilekroć kompilator musi skompilować konstruktor, musi dokładnie wiedzieć, ile pamięci musi przeznaczyć na taki obiekt.

np

class Foo { 
    double bar; //8 bytes 
    int goo; //4 bytes 
} 

'nowe Foo()' wymaga przydział pamięci 12 bajtów. Ale jeśli pozwolono ci rozszerzyć definicje klas na wiele plików (tzn. Podzielić pliki nagłówkowe), łatwo by się z tym bałagan. Twój kompilator nigdy by się nie dowiedział, gdybyś powiedział mu wszystko na temat klasy, czy też tego nie zrobiłeś. Różne miejsca w kodzie mogą mieć różne definicje twojej klasy, co prowadzi do błędów segmentacji lub bardzo tajemniczych błędów kompilatora.

Na przykład:

h1.h:

class Foo { 
    double bar; //8 bytes 
    int goo; //4 bytes 
} 

h2.h: include "h1.h"

class Foo { 
    double goo; //8 bytes 
}// we extend foo with a double. 

foo1.cpp:

#include "foo1.h" 

Foo *makeFoo() { 
    return new Foo(); 

} 

foo2.cpp:

#include "foo2.h" 

void cleanupFoo(Foo *foo) { 
    delete foo; 
} 

foo1.h:

#include "h1.h" 

Foo *makeFoo(); 

foo2.h:

#include "h1.h" 
#include "h2.h" 

void cleanupFoo(Foo *foo) 

main.cpp:

#include foo1.h 
#include foo2.h 

void main() { 
    Foo *foo = makeFoo(); 
    cleanupFoo(foo); 
} 

Teraz bardzo uważnie sprawdzić, co się dzieje, jeśli najpierw skompilować main.cpp do main.o, następnie foo1.cpp do foo1.o i foo2.cpp do foo2.o, i fi połączyć wszystkie razem. To powinno się skompilować, ale makeFoo() przydziela coś innego, niż cleanallFoo() deallocated.

Więc nie ma, podziel się plikami .cpp, ale nie dziel się klasami na pliki nagłówkowe.

Answer 7

 //yes it is possible using preprocessor like this: 

     #define $ ClassName //in .cpp 

    void $::Method1() 
    { 
    } 

    //or like this: in the header .h: 

     #undef $ 
     #define $ ClassName' 

// but you have to include the class header in last #include in your .cpp: 

     #include "truc.h" 
     #include "bidule.h" ... 
     #include "classname.h" 

     void $::Method() { } 

     //i was using also 
     #define $$ BaseClass 
     //with single inheritance than i can do this: 

     void $::Method() 
     { 
     $$::Method(); //call base class method 
     } 

     //but with a typedef defined into class like this it's better to do this: 
     class Derived : Base 
     { 
     typedef Base $$; 

    }