Checking Output Errors in C and C++ - c++

Question

I wrote this simple program. I know that the printf() function in C returns the total number of characters successfully printed so the following C program works fine because any non-zero value is evaluated as true in C.
#include <stdio.h>
int main(void)
{
if (printf("C"))
return 0;
}
But why does the following C++ program compiles & runs fine? If cout is an object not a function, then why is the program giving the expected output?
#include <iostream>
using namespace std;
int main() {
if (cout << "C++")
// your code goes here
return 0;
}

Answer 1

std::cout << "C++";
is a function call to std::operator<<(std::cout, const char*) which returns a reference to std::cout which is convertible to bool. It will evaluate to true if no error on std::cout occurred.

Answer 2

The << operator returns cout. This is why you can chain the << operator like this:
std::cout << "Hello" << " " << "C++" << " " << "World!" << std::endl;
The returned cout will implicitly conver to the value true in the if.

Answer 3

I'm not exactly sure what you are trying to do but assuming you want your program to exit successfully if and only if the printing succeeded, you should write this in C:
#include <stdlib.h>
#include <stdio.h>
int
main()
{
if(printf("C") < 0)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
The reason is that printf will return a negative number to report errors and –1 is considered “true” as well.
The corresponding C++ program should look like this:
#include <cstdlib>
#include <iostream>
int
main()
{
if (!(std::cout << "C++"))
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
The reason this works is that calling operator << on std::cout returns a reference to the stream itself, which also is why things like
std::cout << "You've got " << 99 << " points" << std::endl;
work. Each invocation returns a reference to std::cout upon which the next invocation is performed.
Now, std::basic_ios which std::cout is derived from, defines a conversion operator. Since C++11, this is declared as
explicit operator bool() const;
This means that if the stream is evaluated in a boolean context such as as the condition in an if statement, it is converted to a bool. The table at the bottom of the linked page shows under what conditions the returned bool will be true or false. In summary: it will return true unless an error occurred on the stream.
Before C++11 (when we didn't have explicit operators), a void * pointer was returned that was non-NULL if and only if no errors on the stream occurred. And again, a void * pointer can be evaluated in a boolean context.
Be aware that in both programs shown above, the tests could indicate success but the output may still fail. The reason for this is that output is usually buffered inside the program and only if enough output is gathered will the operating system be asked to actually do the output. You can request a flush at any time to make this happen now. In C, you would call fflush on the respective FILE * pointer.
#include <stdlib.h>
#include <stdio.h>
int
main()
{
if(printf("C") < 0 || fflush(stdout) < 0)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
In C++, you can use the std::flush constant.
#include <cstdlib>
#include <iostream>
int
main()
{
if (!(std::cout << "C++" << std::flush))
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
If you also want a newline, you can use std::endl. Writing
std::cout << "hello, world\n" << std::flush;
has about the same effect as writing
std::cout << "hello, world" << std::endl;
Note however that output buffering is used for performance reasons so if you routinely flush your buffers after each and every output statement, you might well degrade the performance of your program.
Finally, in C++ you can also ask a stream to throw an exception if an error occurs. Since I/O errors should not happen during normal operation and repetitively checking for them can clutter your code, this might come in handy.
#include <cstdlib>
#include <iostream>
int
main()
{
std::cout.exceptions(std::ifstream::failbit);
try
{
std::cout << "C++" << std::flush;
return EXIT_SUCCESS;
}
catch (const std::ios_base::failure &e)
{
return EXIT_FAILURE;
}
}
If you want to test whether your program reports the correct exit status for failed I/O, you can try piping standard output to /dev/full on POSIX systems. /dev/full is a special file that pretends that nothing can be written to it because the file system's capacity is exceeded.

Answer 4

Because this is the same as writing
cout << "C++";
if(cout){
//do whatever
}
It just writes "C++" to cout and checks if your stream is still open.