J'ai vu qu'il existe plusieurs paradigmes différents en C ++ concernant ce qui va dans le fichier d'en-tête et ce qui est dans le fichier cpp. AFAIK, la plupart des gens, en particulier ceux issus du C, font:
foo.h
class foo {
private:
int mem;
int bar();
public:
foo();
foo(const foo&);
foo& operator=(foo);
~foo();
}
foo.cpp
#include foo.h
foo::bar() { return mem; }
foo::foo() { mem = 42; }
foo::foo(const foo& f) { mem = f.mem; }
foo::operator=(foo f) { mem = f.mem; }
foo::~foo() {}
int main(int argc, char *argv[]) { foo f; }
Cependant, mes professeurs enseignent généralement le C ++ à des débutants comme celui-ci:
foo.h
class foo {
private:
int mem;
int bar() { return mem; }
public:
foo() { mem = 42; }
foo(const foo& f) { mem = f.mem; }
foo& operator=(foo f) { mem = f.mem; }
~foo() {}
}
foo.cpp
#include foo.h
int main(int argc, char* argv[]) { foo f; }
// other global helper functions, DLL exports, and whatnot
Originaire de Java, je suis également toujours resté sur cette deuxième voie pour plusieurs raisons, comme le fait que je n'ai à changer quelque chose au même endroit que si les noms d'interface ou de méthode changent, que j'aime les différentes indentations des choses dans les classes quand je regardez leur implémentation, et que je trouve les noms plus lisibles par foo
rapport à foo::foo
.
Je veux collecter des avantages et des inconvénients dans les deux cas. Peut-être qu'il y a même encore d'autres façons?
Un inconvénient de ma voie est bien sûr la nécessité de faire des déclarations prévisionnelles occasionnelles.
foo.cpp
n'a plus rien à voir avec votrefoo
classe et devrait être laissé vide (peut-être mais#include
pour rendre votre système de construction heureux).