L’expression doit avoir un type de classe

Je n’ai pas codé en c ++ depuis un certain temps et je me suis retrouvé coincé quand j’ai essayé de comstackr cet extrait simple

#include "iostream" using namespace std; class A { public: void f() { cout<<"f()\n"; } }; int main() { // A a; //this works A *a = new A(); //this doesn't af(); // "f has not been declared" system("pause"); } 

    C’est un pointeur, alors essayez plutôt:

     a->f(); 

    Fondamentalement, l’opérateur . (utilisé pour accéder aux champs et méthodes d’un object) est utilisé sur les objects et les références, donc:

     A a; af(); A& ref = a; ref.f(); 

    Si vous avez un type de pointeur, vous devez d’abord le déréférencer pour obtenir une référence:

     A* ptr = new A(); (*ptr).a(); ptr->a(); 

    La notation a->b est généralement un raccourci pour (*a).b .

    Autoriser une parsing.

     #include  // not #include "iostream" using namespace std; // in this case okay, but never do that in header files class A { public: void f() { cout< <"f()\n"; } }; int main() { /* // A a; //this works A *a = new A(); //this doesn't af(); // "f has not been declared" */ // below // system("pause"); <-- Don't do this. It is non-portable code. I guess your // teacher told you this? // Better: In your IDE there is prolly an option somewhere // to not close the terminal/console-window. // If you compile on a CLI, it is not needed at all. } 

    Comme conseil général:

     0) Prefer automatic variables int a; MyClass myInstance; std::vector myIntVector; 1) If you need data sharing on big objects down the call hierarchy, prefer references: void foo (std::vector const &input) {...} void bar () { std::vector something; ... foo (something); } 2) If you need data sharing up the call hierarchy, prefer smart-pointers that automatically manage deletion and reference counting. 3) If you need an array, use std::vector<> instead in most cases. std::vector<> is ought to be the one default container. 4) I've yet to find a good reason for blank pointers. -> Hard to get right exception safe class Foo { Foo () : a(new int[512]), b(new int[512]) {} ~Foo() { delete [] b; delete [] a; } }; -> if the second new[] fails, Foo leaks memory, because the destructor is never called. Avoid this easily by using one of the standard containers, like std::vector, or smart-pointers. 

    En règle générale: Si vous avez besoin de gérer vous-même la mémoire, il existe généralement un super gestionnaire ou une alternative, qui suit le principe RAII.

    Résumé : Au lieu de af(); ce devrait être a->f();

    Dans main, vous avez défini un pointeur sur l’ object de A , vous pouvez donc accéder aux fonctions à l’aide de l’opérateur -> .

    af() aurait pu être utilisé pour accéder à f (), si a était déclaré comme: A a;

    a est un pointeur. Vous devez utiliser -> , pas .