Cuando tipos I lo siguiente como una línea independiente:C++ - declaración no puede resolver la dirección de la función sobrecargada
std::endl;
me dieron el siguiente error:
statement cannot resolve address for overloaded function
¿Por qué es ¿ese? ¿No puedo escribir std::endl; como una línea independiente?
Gracias.
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 transmisión en cuestión se definirá como p. ostream& operator<< ( ostream& (*f)(ostream&)). Se define el tipo de argumento de f, por lo que el compilador conocerá 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 se puede resolver la ambigüedad de 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 suministra como un argumento a operator <<: existe 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 a, p. std::cout << std::endl;.
¡Buena pregunta!
'std :: endl' es una plantilla de función única, no una función o conjunto de funciones sobrecargadas. Si fuera solo una función, la declaración 'std :: endl;' estaría bien (si no tiene sentido). –
@Charles Bailey: corregido por eso; ¿Cambiaría mucho el razonamiento? No lo creo. La ambigüedad se resuelve usando el 'operador <<' en casu. – xtofl
Hace el razonamiento más aplicable, en todo caso. –
La más probable razón que se me ocurre es que de la declaración es:
ostream& endl (ostream& os);
En otras palabras, sin ser parte de una operación de <<, no hay os que se puede deducir. Estoy bastante seguro de que este es el caso desde la línea:
std::endl (std::cout);
compila muy bien.
Mi pregunta es: ¿por qué usted quiere para hacer esto?
Sé que es un hecho de que 7; es una declaración perfectamente válido en C pero no ven ese tipo de basura contaminando mi código :-)
Lo hice de esa manera para la búsqueda de legibilidad, y eso indica que se ha insertado una línea nueva después de una declaración. Pero parece que no es válido escribirlo de la manera en que lo hice. Gracias – Simplicity
El std::endl termina una línea y vacía el búfer. Por lo tanto, debe estar conectado a la corriente como cout o similar.
endl es una función que toma un parámetro. Ver std::endl on cplusplus.com
// This works.
std::endl(std::cout);
http://www.cplusplus.com/reference/iostream/manipulators/endl/
No se puede tener std::endl por sí mismo, ya que requiere un basic_ostream como un tipo de parámetro. Es la forma en que se define.
Es como tratar de llamar my_func() cuando la función se define como void my_func(int n)
std :: endl es un manipulador. En realidad, es una función que llama la versión del operador < < en una transmisión.
std::cout << std::endl
// would call
std::endl(std::cout).
std::endl es una plantilla de función. Si lo usa en un contexto donde el argumento de la plantilla no puede determinarse de manera única, debe desambiguar a qué especialidad se refiere. Por ejemplo, puede usar un molde explícito o asignarlo 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;
}
Normalmente, solo lo utiliza 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);
}
#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");
}
Cuál de línea de corriente tendría que terminar? – dreamlax