tipos - C++: la sentencia no puede resolver la dirección de la función sobrecargada

tipos de error en c++

Question

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 linea independiente?

Gracias.

Answer 1

El std::endl termina una línea y vacía el búfer. Así que debe estar conectado el flujo como cout o similar.

Answer 2

La razón más probable que puedo pensar es que su declaración es:

ostream& endl ( ostream& os );

En otras palabras, sin ser parte de una operación << , no hay un sistema operativo que pueda inferirse. Estoy bastante seguro de que este es el caso desde la línea:

std::endl (std::cout);

compila bien

Mi pregunta para ti es: ¿por qué querrías hacer esto?

Sé por un hecho que 7; Es una declaración perfectamente válida en C, pero no ves ese tipo de basura que contamina mi código :-)

Answer 3

endl es una función que toma un parámetro. Vea http://www.cplusplus.com/reference/iostream/manipulators/endl/

// This works.
std::endl(std::cout);

Answer 4

std :: endl es un manipulador. En realidad, es una función a la que llama la versión a del operador << en una transmisión.

std::cout << std::endl
// would call
std::endl(std::cout).

Answer 5

std::endl es una plantilla de función. Normalmente, se usa como argumento para el operador de inserción << . En ese caso, el operator<< del flujo 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 algunos consejos de tipo:

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 un argumento al operator << : hay una definición de la función

 typedef (ostream& (*f)( ostream& ) ostream_function;
ostream& operator<<( ostream&, ostream_function )

Y esto permitirá que el compilador elija la sobrecarga correcta de std::endl cuando se suministre, por ejemplo, a std::cout << std::endl; .

¡Buena pregunta!

Answer 6

http://www.cplusplus.com/reference/iostream/manipulators/endl/

No puede tener std::endl por sí mismo 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 se define como void my_func(int n)

Answer 7

std::endl es una plantilla de función. Si lo usa en un contexto en el que el argumento de la plantilla no se puede determinar de manera única, tiene que desambiguar a qué especialización se refiere. Por ejemplo, puede usar 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 lo usa en un contexto en el que el argumento de la plantilla se deduce automáticamente.

#include <iostream>
#include <ostream>
int main()
{
std::cout << std::endl;
std::endl( std::cout );
}

Answer 8

#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");
}