Es importante interpretar el código bien antes de utilizarlo a tu trabajo si ttienes algo que aportar puedes dejarlo en la sección de comentarios.
Solución:
Es un puntero, así que en su lugar intente:
a->f();
Básicamente el operador . (usado para acceder a los campos y métodos de un objeto) se usa en objetos y referencias, por lo que:
A a;
a.f();
A& ref = a;
ref.f();
Si tiene un tipo de puntero, primero debe desreferenciarlo para obtener una referencia:
A* ptr = new A();
(*ptr).f();
ptr->f();
El a->b notación suele ser sólo una abreviatura de (*a).b.
Una nota sobre los punteros inteligentes
El operator-> se puede sobrecargar, lo que es especialmente utilizado por los punteros inteligentes. Cuando usa punteros inteligentes, también usa -> para referirse al objeto señalado:
auto ptr = make_unique();
ptr->f();
Permitir un análisis.
#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
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.
Como consejo general:
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.
Como regla general: si necesita administrar la memoria por su cuenta, generalmente ya hay un administrador superior o una alternativa disponible, una que sigue el principio RAII.
Resumen: En vez de a.f(); debería ser a->f();
En main has definido a como un puntero a objeto deA, para que pueda acceder a las funciones usando el -> operador.
Un alterno, pero la forma menos legible es (*a).f()
a.f() se podría haber usado para acceder a f(), si a fue declarado como:
A a;
Finalizando este artículo puedes encontrar las explicaciones de otros usuarios, tú además puedes dejar el tuyo si lo crees conveniente.