Char og memory address

[Dead_Rabbit]

cout er da uten tvil å foretrekke over printf. Ikke bare er det normen i C++ å bruke cout fremfor printf, men det er også mer fleksibelt og jeg synes at det ser bedre ut også. Prøv f.eks. å "operator-overlaste printf" for å skrive ut en egendefinert type. Det blir jo klønete.

Skriv deg to små programmer som skriver ut en tekststreng 1000000 ganger med printf og cout. Ta tiden på hver av dem via "time" et par ganger.

Det er da sjeldent at man har behov for å skrive ut så store mengder data at cout er en flaskehals, så om printf er raskere bryr jeg meg lite om. Jeg synes man gjør et godt tradeoff uansett mht. at man får streams og muligheten til å f.eks. overlaste operator<< på egendefinerte typer.

 

Speaking of which, GeirGrusom, hvorfor liker du ikke overlasting av operator<<? Jeg kan kanskje forstå operator>>, men ikke operator<<.

[GeirGrusom]

Eksempel:

quit()
{
 exit(0);
}
quit(int code)
{
 exit(code);
}
// And now for something completely different
quit(std::string cmd)
{
 system(string("shutdown ") + cmd)
}

 

Ville noen her noensinne skrevet noe slikt? Hvorfor er det plutselig greit når det er operators?

[Dead_Rabbit]

Selv om det går an å bruke en feature til å skrive idiotisk kode er det da ikke dermed sagt at alt ved det er idiotisk. Alternativet til å overlaste f.eks. operator<< er jo å ha en print-funksjon i hver klasse, og det er etter min mening en dårlig løsning. Ta f.eks. hvis man har en template-funksjon som skal skrive ut data til skjermen:

#include <iostream>

using namespace std;

template<class T>
void print_stuff(T something)
{
cout << something << endl;
}

class Foo { };

ostream& operator<<(ostream& os, Foo& f)
{
os << "foobaaarbaaz";
return os;
}

class Bar { 
public:
	void print() { cout << "Jeg er sær, jeg"; }
};

int main(int argc, char* argv[])
{
print_stuff(5);
print_stuff(Foo());
//print_stuff(Bar());

return 0;
}

Hvis den siste linja som kaller print_stuff ikke var kommentert bort, hadde jo hælvete brutt løs om man hadde prøvd å kompilere det. I C++ så er jo det å bruke streams nærmest standard for input og output, så derfor ser jeg ikke vitsen i å ikke overlaste stream-operatorene. Merk at koden over selvfølgelig ikke hadde fungert med f.eks. built-in typer hvis man hadde gått ut i fra at objektene hadde antatt at alle typer hadde en egen print-funksjon.

[GeirGrusom]

Mitt forslag:

cout.print("Hello World!:").print(123).newline().print("I have the POWAH!").newline();

Så er det ingen tvil om hva som foregår.

 

for eksempel

 

cout.print(255 << 1).newline();

mot

cout << (255 << 1) << endl;

 

og for å skrive andre objekter kunne de laget en abstrakt klasse:

 

class printobj
{
 virtual ostream& print(ostream owner) = 0;
};

class cout : blabalabla
{
 ostream& print(printobj& obj)
 {
return obj.print();
 }
};

//...

class MyHelloWorldClass : printobj
{
 ostream& print(ostream& owner)
 {
return owner.print("Hello World!").newline();
 }
}

int main()
{
 MyHelloWorldClass hello = MyHelloWorldClass();
 cout.print(hello).print("FOO!!").newline();
}

Endret 4. mars 2009 av GeirGrusom

[GeirGrusom]

I Win?

[Dead_Rabbit]

Hmf, ikke prøv deg a!

 

Rent teknisk blir det jo ikke store forskjellen fra hvordan ting er i dag. Jeg synes at standardbiblioteket gjør et godt tradeoff mellom kosmetikk og "logikk" i dette tilfellet. At det kan i noen få små tilfeller noen enkelte ganger virke en ørliten smule forvirrende at operator>> og operator<< "plutselig" er for input og output istedenfor shifting bør man ærlig talt kunne takle. \o/