C++: la declaración no puede resolver la dirección de una función sobrecargada
Pregunta
Cuando escribo lo siguiente como una línea independiente:
std::endl;
Tuve el siguiente error:
statement cannot resolve address for overloaded function
¿Porqué es eso?¿No puedo escribir? std::endl;
¿Como una línea independiente?
Gracias.
Solución
std::endl
es una plantilla de función.Normalmente, se usa como argumento para el operador de inserción. <<
.En ese caso, el operator<<
de la corriente en cuestión se definirá como, por ejemplo, ostream& operator<< ( ostream& (*f)( ostream& ) )
.El tipo de argumento de f
está definido, por lo que el compilador sabrá la sobrecarga exacta de la función.
Es comparable a esto:
void f( int ){}
void f( double ) {}
void g( int ) {}
template<typename T> void ft(T){}
int main(){
f; // ambiguous
g; // unambiguous
ft; // function template of unknown type...
}
Pero puedes resolver la ambigüedad con algunas sugerencias tipográficas:
void takes_f_int( void (*f)(int) ){}
takes_f_int( f ); // will resolve to f(int) because of `takes_f_int` signature
(void (*)(int)) f; // selects the right f explicitly
(void (*)(int)) ft; // selects the right ft explicitly
Eso es lo que sucede normalmente con std::endl
cuando se proporciona como argumento para operator <<
:hay una definición de la función
typedef (ostream& (*f)( ostream& ) ostream_function;
ostream& operator<<( ostream&, ostream_function )
Y esto permitirá al compilador elegir la sobrecarga correcta de std::endl
cuando se suministra a, p. std::cout << std::endl;
.
¡Buena pregunta!
Otros consejos
lo mas probable La razón que se me ocurre es que su declaración es:
ostream& endl ( ostream& os );
En otras palabras, sin ser parte de una <<
operación, no hay os
que se puede inferir.Estoy bastante seguro de que este es el caso desde la línea:
std::endl (std::cout);
se compila muy bien.
Mi pregunta para ti es:por que lo harias desear ¿para hacer esto?
Sé con certeza que 7;
es una declaración perfectamente válida en C pero no ves ese tipo de basura contaminando mi código :-)
std::endl
es una plantilla de función.Si lo usa en un contexto donde el argumento de la plantilla no se puede determinar de forma única, debe eliminar la ambigüedad a qué especialización se refiere.Por ejemplo, puede utilizar una conversión explícita o asignarla a una variable del tipo correcto.
p. ej.
#include <ostream>
int main()
{
// This statement has no effect:
static_cast<std::ostream&(*)(std::ostream&)>( std::endl );
std::ostream&(*fp)(std::ostream&) = std::endl;
}
Por lo general, solo se usa en un contexto donde el argumento de la plantilla se deduce automáticamente.
#include <iostream>
#include <ostream>
int main()
{
std::cout << std::endl;
std::endl( std::cout );
}
http://www.cplusplus.com/reference/iostream/manipulators/endl/
No puede tener std::endl
por sí solo porque requiere un basic_ostream
como tipo de parámetro.Es la forma en que se define.
Es como intentar llamar a my_func()
cuando la función está definida como void my_func(int n)
endl es una función que toma un parámetro.Consulte std :: endl en cplusplus.com
// This works.
std::endl(std::cout);
std :: endl es un manipulador.En realidad, es una función a la que llama la versión a del operador << en una secuencia.
std::cout << std::endl
// would call
std::endl(std::cout).
El std::endl
termina una línea y vacía el búfer.Entonces debería estar conectado a la transmisión como cout
o similar.
#include<iostream>
#include<conio.h>
#include<string.h>
using namespace std;
class student{
private:
string coursecode;
int number,total;
public:
void getcourse(void);
void getnumber(void);
void show(void);
};
void student ::getcourse(){
cout<<"pleas enter the course code\n";
cin>>coursecode;
}
void student::getnumber(){
cout<<"pleas enter the number \n";
cin>>number;
}
void student::show(){
cout<<"coursecode is\t\t"<<coursecode<<"\t\t and number is "<<number<<"\n";
}
int main()
{
student s;
s.getcourse();
s.getnumber();
s.show();
system("pause");
}