c++ - descargar - error: solicitud para el miembro ''..'' en ''..'' que no es de clase

c++ manual

Question

Tengo una clase con dos constructores, uno que no toma argumentos y otro que toma un argumento.

La creación de objetos utilizando el constructor que toma un argumento funciona como se espera. Sin embargo, si creo objetos usando el constructor que no toma argumentos, obtengo un error.

Por ejemplo, si compilo este código (usando g ++ 4.0.1) ...

class Foo
{
public:
Foo() {};
Foo(int a) {};
void bar() {};
};
int main()
{
// this works...
Foo foo1(1);
foo1.bar();
// this does not...
Foo foo2();
foo2.bar();
return 0;
}

... Obtuve el siguiente error:

nonclass.cpp: In function ‘int main(int, const char**)’:
nonclass.cpp:17: error: request for member ‘bar’ in ‘foo2’, which is of non-class type ‘Foo ()()’

¿Por qué es esto, y cómo lo hago funcionar?

Answer 1

Agregando a la base de conocimientos, obtuve el mismo error para

if(class_iter->num == *int_iter)

A pesar de que el IDE me dio los miembros correctos para class_iter. Obviamente, el problema es que "anything"::iterator no tiene un miembro llamado num así que necesito desreferenciarlo. Que no funciona así:

if(*class_iter->num == *int_iter)

...aparentemente. Eventualmente lo resolví con esto:

if((*class_iter)->num == *int_iter)

Espero que esto ayude a alguien que se encuentre con esta pregunta como yo lo hice.

Answer 2

Ciertamente, un caso de esquina para este error, pero lo recibí en una situación diferente, al intentar sobrecargar el operator= asignación operator= . Fue un IMO un poco críptico (de g ++ 8.1.1).

#include <cstdint>
enum DataType
{
DT_INT32,
DT_FLOAT
};
struct PrimitiveData
{
union MyData
{
int32_t i;
float f;
} data;
enum DataType dt;
template<typename T>
void operator=(T data)
{
switch(dt)
{
case DT_INT32:
{
data.i = data;
break;
}
case DT_FLOAT:
{
data.f = data;
break;
}
default:
{
break;
}
}
}
};
int main()
{
struct PrimitiveData pd;
pd.dt = DT_FLOAT;
pd = 3.4f;
return 0;
}

Recibí 2 errores "idénticos"

error: request for member ‘i’ [and ''f''] in ‘data’, which is of non-class type ‘float’

(El error equivalente para clang es: error: member reference base type ''float'' is not a structure or union )

para las líneas data.i = data; y data.f = data; . Resulta que el compilador estaba confundiendo el nombre de la variable local ''datos'' y los datos de mi variable miembro. Cuando cambié esto a void operator=(T newData) y data.i = newData; , data.f = newData; , el error se fue.

Answer 3

Estaba teniendo un error similar, parece que el compilador no entiende la llamada al constructor sin argumentos. Lo hice funcionar eliminando el paréntesis de la declaración de variable, en su código algo como esto:

class Foo
{
public:
Foo() {};
Foo(int a) {};
void bar() {};
};
int main()
{
// this works...
Foo foo1(1);
foo1.bar();
// this does not...
Foo foo2; // Without "()"
foo2.bar();
return 0;
}

Answer 4

Los paréntesis no son necesarios para crear una instancia de un objeto de clase cuando no tiene la intención de utilizar un constructor parametrizado.

Sólo tiene que utilizar Foo foo2;

Funcionará.

Answer 5

Me encontré con un caso donde recibí ese mensaje de error y tuve

Foo foo(Bar());

y básicamente estaba tratando de pasar un objeto Bar temporal al constructor Foo. Resulta que el compilador estaba traduciendo esto a

Foo foo(Bar(*)());

es decir, una declaración de función cuyo nombre es foo que devuelve un Foo que toma un argumento, un puntero de función que devuelve una barra con 0 argumentos. Cuando se pasan temporarios como este, es mejor usar Bar{} lugar de Bar() para eliminar la ambigüedad.

Answer 6

Si desea declarar una sustancia nueva sin parámetros (sabiendo que el objeto tiene parámetros predeterminados) no escriba

 type substance1();

pero

 type substance;

Answer 7

Solo para que conste..

En realidad no es una solución para su código, pero tuve el mismo mensaje de error cuando myPointerToClass incorrectamente al método de una instancia de clase apuntada por myPointerToClass , por ejemplo

MyClass* myPointerToClass = new MyClass();
myPointerToClass.aMethodOfThatClass();

dónde

myPointerToClass->aMethodOfThatClass();

obviamente sería correcto

Answer 8

Foo foo2();

cambiar a

Foo foo2;

Recibes el error porque el compilador piensa

Foo foo2()

a partir de la declaración de la función con el nombre ''foo2'' y el tipo de retorno ''Foo''.

Pero en ese caso, si cambiamos a Foo foo2 , el compilador podría mostrar el error " call of overloaded ''Foo()'' is ambiguous" .