using constructors for primitive types?!

I have used before:

class A
{

};

operator& operator<<(operator& out, A& a);

cout << A();

I used thinking this spent fewer memory than doing something like:

A a;
cout << a;

Now I tried this and it worked:

cout << int(0);

Is this compiler-dependent or is a language feature?

Gaijinco wrote:
That may or may not use more memory. The compiler is free to optimize away
the variable unless it would change the observable behavior of the program.

It is a language feature. It is important, e.g., in templated code where it
allows one to treat built-in types and user defined classes uniformly.


Best

Kai-Uwe Bux

Gaijinco wrote:What is operator (the type) here? You can't have a type named so. Did you
mean std::ostream?
For outputting it would be wise to make the reference const:

std::ostream& operator<<(std::ostream& out, const A& a);
It would be the same, I guess. Why should it use more or less memory?
What is compiler-dependent?

cout can output an integer, of course. It's like:

cout << 42;

--
Thomas
http://www.netmeister.org/news/learn2quote.html

Gaijinco wrote:
That is not a call to the int constructor. Int doesn't
have a constructor. It is an explicit conversion to
int. It is (by definition in the language) exactly the
same as:
cout << (int) 0;

Int doesn'tAnd what's the case when you use:

class A
{
int x;
A(int z): x(z){};
}

Thanks.

On Jun 18, 8:20 am, Gaijinco <gaiji...@gmail.comwrote:
You should also take care the following while using paranthesis with
defualt contructor. Moreover it's a temporary object.

http://www.parashift.com/c++-faq-lit....html#faq-10.2

Gaijinco wrote:That's an initialiser, different beast.

--
Ian Collins.

On Jun 18, 2:10 am, Ron Natalie <r...@spamcop.netwrote:That's true, but:
cout << A(0) ;
is also the same as:
cout << (A)0 ;
and
cout << static_cast< A >( 0 ) ;

They're all conversions (according to the standard). The only
real difference is that "type(arg_list)" allows any number of
args (including 0), where as the two other syntaxes only work
with exactly one argument, and that "type(arg_list)" requires
that the type be a single token or a qualified name, where as
the two other syntaxes accept more complicated type names (like
"unsigned long"). But the standard still qualifies all as "type
conversions" (and defines the semantics of A(arg) in terms of
static_cast when there is a single argument).

--
James Kanze (GABI Software, from CAI) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Gaijinco wrote:Same thing. Except that classes have constructors
that are called by the implementation to initialize
them.