L'Expression doit avoir un type de classe
Je n'ai pas codé en class="blnk">C++ depuis un certain temps et je suis resté coincé quand j'ai essayé de compiler 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
a.f(); // "f has not been declared"
system("pause");
}
4 réponses
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 objet) est utilisé sur les objets et les références, donc:
A a;
a.f();
A& ref = a;
ref.f();
Si vous avez un type de pointeur, vous devez déréférencement d'abord pour obtenir une référence:
A* ptr = new A();
(*ptr).a();
ptr->a();
Le a->b la notation est généralement juste un raccourci pour (*a).b.
Autoriser une analyse.
#include <iostream> // 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
a.f(); // "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 un conseil général:
0) Prefer automatic variables
int a;
MyClass myInstance;
std::vector<int> myIntVector;
1) If you need data sharing on big objects down
the call hierarchy, prefer references:
void foo (std::vector<int> const &input) {...}
void bar () {
std::vector<int> 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 la mémoire par vous-même, il existe généralement un gestionnaire supérieur ou une alternative déjà disponible, celui qui suit le principe RAII.
Résumé: au Lieu de a.f();, il devrait être a->f();
Principale, vous avez défini un comme un pointeur vers objet de Un, de sorte que vous pouvez accéder à des fonctions à l'aide de la -> opérateur.
a.f() aurait pu être utilisé pour accéder à f (), SI a a été déclaré comme:
A a;