🎄 Merry Christmas 🎄

Merry Xmas girls ( if any

Of course we have~

That's ... unexpected🤣

Why do we use reference of ostream/istream in operator overloading of insertion and extraction operator?

I know little about C++. But I think rather than copying a whole "entity" of ostream/istream, it'd be much better to just copy and pass a "pointer"

I think We are using whole entity in both the cases!!

No. If you don't use reference, a new copy of the former osteam/istream "entity" will be created ... it costs time & memory

Yes, with a lower performance

Merry Christmas

Hey guys i hav no idea about swtich case...

Instead of using reference can't we have used return type ostream/istream directly?

#include <iostream> #include <stdio.h> #include <stdlib.h> #include <time.h> using namespace std; int main() { string date; struct tm *tim; time_t tt = time(NULL); tim = localtime(&tt); int theDay = tim->tm_mday; int theMonth = tim->tm_mon; int theYear = tim->tm_year+1900; printf ("%d.%d.%d",theYear,theMonth,theDay); // Here possible to write like this: std::cout << theYear << "." << theMonth << "." << theDay; cout << endl; cout << "Enter a date, please: "; cin >> date; cout << endl; if (date == "22/12/1999") cout << "Happy Birthday, cryptpi!" << endl; // There you can write something else, what you want. return 0; }

No you can not, since both objects of istream and ostream are non-copyable, and when functions return, they copy local variable to their callers.

No you can not, since both objects of istream and ostream are non-copyable, and when functions return, they copy local variable to their callers.

Can we write a copy constructor to make it copyable?

Can we write a copy constructor to make it copyable?

There is another reason why we always return a reference to streams. Since insertion and extraction opreators are actually functions, calling something like: std::cout << "hello " << "world\n"; equals to operator<<(operator<<(std::cout, "hello"), "world\n") As you can see, the return of first calling will then be treated as input paramter of the second calling. If this kind of functions/operators do not return reference to streams, this kind of calling will then be invalid.

i fear this notation

lol, just for showing something. nobody will use it in real codes.

maybe move semantics work in your case

Move constructor and assignment are protected, so...

move constructor too?

yes, try to compile #include <iostream> std::ostream foo(std::ostream& os) { return std::move(os); } int main() { foo(std::cout); return 0; } gives you error: std::basic_ostream<_CharT, _Traits>::basic_ostream(std::basic_ostream<_CharT, _Traits>&&) [with _CharT = char; _Traits = std::char_traits<char>]’ is protected within this context return std::move(os); ^

Hi guys. I'm just familiar with C and start to learn C++. What book should I read to understand the implementation details like istream/ostream?

faint, your turn..

faint, your turn..

Hi guys. I'm just familiar with C and start to learn C++. What book should I read to understand the implementation details like istream/ostream?

If you're new to C++, I would not recommend you to read impl details like istream/ostream. It's so complecated with template tricks. Read introduction books first, and then dive into STL codes, if you like.

No you can not, since both objects of istream and ostream are non-copyable, and when functions return, they copy local variable to their callers.

why would you want to transfer a copy of cout?

double income 🤔

look, you have to notice that, there exists something that is not copyable. def foo(father): // do something, such as hair cut return father If the return type is Father, it means that after hair cut, you got two fathers. That's redicilous, isn't it?

double scolding

look, you have to notice that, there exists something that is not copyable. def foo(father): // do something, such as hair cut return father If the return type is Father, it means that after hair cut, you got two fathers. That's redicilous, isn't it?

s/red/rid

Well, I'm gonna get used to my poor English.