iostream

Operators in C++ are usually considered to be an alternative syntax for functions/methods, especially in the context of overloading. If so, the two expressions below should be synonymous: std::cout << 42; operator<<(std::cout, 42); In practise, the second statement leads to the following error: call of overloaded ‘operator<<(std::ostream&, int)’ is ambiguous As usual, such error message is accompanied with a list of possible candidates, these are: operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) operator<<(basic_ostream<char, _Traits>& __out, char __c) operator<<(basic_ostream<char,

I have the following code: qstn: cout << "Input customer's lastname: "; getline(cin, lname); if (lname.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") != string::npos) { cout << "You can only input alpha here!\n"; cin.clear(); goto qstn; } else if (lname.empty()) { cout << "Please enter your firstname!\n"; cin.clear(); goto qstn; } int lnamel = lname.length(); int strl = str.length(); int is = 0; for (int i = 1; i < strl;) { i++; is++; if (lname[i] == lname[is] && lname[i] == ' ' || lname[0] == ' ') { cin.clear(); cout << "Please input your lastname properly!\n";

Possible Duplicate: Detect if stdin is a terminal or pipe in C/C++/Qt? Consider we got a small program which takes some standard C input. I would like to know if the user is using input redirection, for example like this: ./programm < in.txt Is there a way to detect this way of input redirecting in the program? There's no portable way to do that, since C++ says nothing about where cin comes from. On a Posix system, you can test whether or not cin comes from a terminal or is redirected using isatty , something like this: #include <unistd.h> if (isatty(STDIN_FILENO)) { // not redirected } else {

I am trying to write to file and stdout at the same time within c++ by overloading ofstream test.h #pragma once #include <iostream> using std::ofstream; class OutputAndConsole:public ofstream { public: std::string fileName; OutputAndConsole(const std::string& fileName):ofstream(fileName),fileName(fileName){ }; template <typename T> OutputAndConsole& operator<<(T var); }; template <typename T> OutputAndConsole& OutputAndConsole::operator<<(T var) { std::cout << var; ofstream::operator << (var); return (*this); }; test.cpp OutputAndConsole file("output.txt"); file << "test" ; The output in the

I understand that by default all stream IO supported by C++ is buffered. This means that data to be output is put into a buffer till it is full and then sent to the output device, similarly for input, the data is read once the buffer is empty...all this is done so that number of expensive system calls could be minimized. But how to verify this behavior in action. I mean consider the following code int main() { cout << "Hello world\n"; return 0 } Where does buffering come into picture here ? I know there is buffering happening, but how to explain it? The output is seen instantly on the screen,