C++ - statement cannot resolve address for overloaded function - c++

Question

When I types the following as a stand-alone line:
std::endl;
I got the following error:
statement cannot resolve address for overloaded function
Why is that? Cannot I write std::endl; as a stand-alone line?
Thanks.

Answer 1

std::endl is a function template. Normally, it's used as an argument to the insertion operator <<. In that case, the operator<< of the stream in question will be defined as e.g. ostream& operator<< ( ostream& (*f)( ostream& ) ). The type of the argument of f is defined, so the compiler will then know the exact overload of the function.
It's comparable to this:
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...
}
But you can resolve the ambiguity by some type hints:
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
That's what happens normally with std::endl when supplied as an argument to operator <<: there is a definition of the function
typedef (ostream& (*f)( ostream& ) ostream_function;
ostream& operator<<( ostream&, ostream_function )
And this will enable the compiler the choose the right overload of std::endl when supplied to e.g. std::cout << std::endl;.
Nice question!

Answer 2

The most likely reason I can think of is that it's declaration is:
ostream& endl ( ostream& os );
In other words, without being part of a << operation, there's no os that can be inferred. I'm pretty certain this is the case since the line:
std::endl (std::cout);
compiles just fine.
My question to you is: why would you want to do this?
I know for a fact that 7; is a perfectly valid statement in C but you don't see that kind of rubbish polluting my code :-)

Answer 3

std::endl is a function template. If you use it in a context where the template argument cannot be uniquely determined you have to disambiguate which specialization you mean. For example you can use an explicit cast or assign it to a variable of the correct type.
e.g.
#include <ostream>
int main()
{
// This statement has no effect:
static_cast<std::ostream&(*)(std::ostream&)>( std::endl );
std::ostream&(*fp)(std::ostream&) = std::endl;
}
Usually, you just use it in a context where the template argument is deduced automatically.
#include <iostream>
#include <ostream>
int main()
{
std::cout << std::endl;
std::endl( std::cout );
}

Answer 4

std::endl is a manipulator. It's actually a function that is called by the a version of the << operator on a stream.
std::cout << std::endl
// would call
std::endl(std::cout).

Answer 5

http://www.cplusplus.com/reference/iostream/manipulators/endl/
You can't have std::endl by itself because it requires a basic_ostream as a type of parameter. It's the way it is defined.
It's like trying to call my_func() when the function is defined as void my_func(int n)

Answer 6

endl is a function that takes a parameter. See std::endl on cplusplus.com
// This works.
std::endl(std::cout);

Answer 7

The std::endl terminates a line and flushes the buffer. So it should be connected the stream like cout or similar.

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