Number of ways to create an object

[Peter Ammon]

A friend was asked "How many ways are there to create an object in C++?"
in an interview. Apparently, the "right" answer was eleven. Does
anyone know how the interviewer arrived at that number? Is this fact
well known (if true)?

[Alf P. Steinbach]

On Thu, 29 Jan 2004 10:40:44 -0800, Peter Ammon <pe*********@ro cketmail.com> wrote:

A friend was asked "How many ways are there to create an object in C++?"
in an interview.
The only meaningful answer is 1: by calling a constructor.

Lest idiots yet again object to that terminology: it's the one employed
by the Holy Standard.

Apparently, the "right" answer was eleven. Does
anyone know how the interviewer arrived at that number? Is this fact
well known (if true)?

Any number might be considered correct under suitable assumptions and
using suitable definitions, e.g. of "ways", "create", "object".

[jeffc]

"Peter Ammon" <pe*********@ro cketmail.com> wrote in message
news:bv******** **@news.apple.c om...

A friend was asked "How many ways are there to create an object in C++?"
in an interview. Apparently, the "right" answer was eleven. Does
anyone know how the interviewer arrived at that number? Is this fact
well known (if true)?

That "fact" is not well known, if true. Sounds like one of those goofy
questions where the interviewer has a "one up" by already researching an
obscure problem ahead of time that you couldn't know. Maybe he just wanted
to see how you think about things and get the ball rolling, not come up with
"11". (Frankly, I'm reminded of This Is Spinal Tap at this moment.)

class A;

A a; // 1
A* pA = new A; // 2
f(A()); // 3
etc.

[Ron Natalie]

"Alf P. Steinbach" <al***@start.no > wrote in message news:40******** ********@News.C IS.DFN.DE...

On Thu, 29 Jan 2004 10:40:44 -0800, Peter Ammon <pe*********@ro cketmail.com> wrote:

A friend was asked "How many ways are there to create an object in C++?"
in an interview.
The only meaningful answer is 1: by calling a constructor.

It's wrong. You can't call the constructor. A constructor is called by the
implementation as a byproduct of object created.
Lest idiots yet again object to that terminology: it's the one employed
by the Holy Standard.

No it's not. Even with your quibbling over "is called" verses "calling"
your answer is WRONG. There are two DISTINCT steps in object
creation specifically listed in the standard:

1. First storage is obtained
2. Then construction occurs.

Your incorrect answer totally omits the first step.

[Ron Natalie]

"Peter Ammon" <pe*********@ro cketmail.com> wrote in message news:bv******** **@news.apple.c om...

A friend was asked "How many ways are there to create an object in C++?"
in an interview. Apparently, the "right" answer was eleven. Does
anyone know how the interviewer arrived at that number? Is this fact
well known (if true)?

Well without any better explanation of the problem, any answer might be
correct. Object creation is divided into two steps:

1. Obtaining storage.
2. Construction.

The first is divided into three main categories:

1. Static storage duration, which includes static parts of classes, static variables at namespace
scope, and static variables within functions.
2. Automatic storage duration (your non-static local variables inside functions as well as temporaries).
3. Dynamic storage duration: i.e., that obtained via new. Which includes regular single
object new expressions, array new expressions, each of which can have additional
"placement arguments"

The second phase can be divided into three groups:

1. Default initialization
2. Copy initialization
3. Direct initialization. .

I can easily come up with any number from 3 to over 24 different flavors of object creation
depending on what he means by "way".

[David Harmon]

On Thu, 29 Jan 2004 10:40:44 -0800 in comp.lang.c++, Peter Ammon
<pe*********@ro cketmail.com> was alleged to have written:

A friend was asked "How many ways are there to create an object in C++?"
in an interview. Apparently, the "right" answer was eleven. Does
anyone know how the interviewer arrived at that number? Is this fact
well known (if true)?

I guarantee that if you post his list of eleven "ways", people here will
come up with _both_ additional "ways" that are just as valid as some on
the list, and reasons why some of the eleven are really the "same thing"
and shouldn't be counted twice.

[E. Robert Tisdale]

Ron Natalie wrote:

Alf P. Steinbach wrote:

The only meaningful answer is 1: by calling a constructor.

It's wrong. You can't call the constructor.
A constructor is called by the implementation
as a byproduct of object created.

Lest idiots yet again object to that terminology:
it's the one employed by the Holy Standard.

No it's not.
Even with your quibbling over "is called" verses "calling"
your answer is WRONG. There are two DISTINCT steps
in object creation specifically listed in the standard:

1. First storage is obtained
2. Then [initialization] occurs.

Your incorrect answer totally omits the first step.

Actually, these two steps define construction.
The constructor function is actually an initializer.
The compiler emits code to

1. allocate storage for the object then
2. "calls" the "constructo r" to initialize it.

You can think of a constructor for class C
as a class "friend" function:

C C(. . .);

that returns an object of type C
which can be used in an expression.

[Peter van Merkerk]

"David Harmon" <so****@netcom. com> wrote in message
news:40******** *******@news.we st.earthlink.ne t...

On Thu, 29 Jan 2004 10:40:44 -0800 in comp.lang.c++, Peter Ammon
<pe*********@ro cketmail.com> was alleged to have written:

A friend was asked "How many ways are there to create an object in C++?"
in an interview. Apparently, the "right" answer was eleven. Does
anyone know how the interviewer arrived at that number? Is this fact
well known (if true)?

I guarantee that if you post his list of eleven "ways", people here will
come up with _both_ additional "ways" that are just as valid as some on
the list, and reasons why some of the eleven are really the "same thing"
and shouldn't be counted twice.

Whatever the correct answer is (if there is any at all), who cares? I think
many skilled C++ can't answer that question, and for those who can it says
nothing about their C++ programming skills. You could question however the
C++ skills of the person who asked the question.

--
Peter van Merkerk
peter.van.merke rk(at)dse.nl

[David Harmon]

On Thu, 29 Jan 2004 14:34:35 -0500 in comp.lang.c++, "Ron Natalie"
<ro*@sensor.com > was alleged to have written:

I can easily come up with any number from 3 to over 24 different flavors of object creation
depending on what he means by "way".

Well, it would be pretty difficult to come up with eleven by your
method, since it is a prime number.

[Alf P. Steinbach]

On Thu, 29 Jan 2004 14:28:20 -0500, "Ron Natalie" <ro*@sensor.com > wrote:

"Alf P. Steinbach" <al***@start.no > wrote in message news:40******** ********@News.C IS.DFN.DE...

On Thu, 29 Jan 2004 10:40:44 -0800, Peter Ammon <pe*********@ro cketmail.com> wrote:

>A friend was asked "How many ways are there to create an object in C++?"
>in an interview.
The only meaningful answer is 1: by calling a constructor.

It's wrong. You can't call the constructor.

No? See below.

A constructor is called by the implementation
The machine code that achieves that amazing feat is irrelevant.

Why do you keep on harking about the machine-code level?
as a byproduct of object created.

Lest idiots yet again object to that terminology: it's the one employed
by the Holy Standard.
No it's not.

It is, as you well know from earlier discussions. Have you forgotten? In
that case, allow me to attempt to refresh your failing (ailing?) memory:
§12.1/2 ... an explicit type conversion using the functional notation (5.2.3)
will cause a constructor to be CALLED to initialize an object.

§12.1/5 A default constructor for a class X is a constructor of class X that
can be CALLED without an argument.

§12.1/8 Default constructors are CALLED implicitly to create class objects
of automatic storage duration (3.7.1, 3.7.2) defined without an
initializer (8.5), are CALLED to create class objects of dynamic
storage duration (3.7.3) created by a new-expression in which the
new-initializer is omitted (5.3.4), or are CALLED when the explicit
type conversion syntax (5.2.3) is used.

--> Note especially the distinction here between CALLED IMPLICITLY
and simply CALLED. Perhaps you've been misled to think the
former is always the case, and that's what your apparent
hang-up about the machine code level is about?

--> Note also: "constructo rs" ... "are CALLED".
§12.1/9 [Note: 12.6.2 described the order in which constructors for base
classes and non-static data members CALLED and describes how arguments
can be specified for the CALLS to these constructors.]

§12.1/13 ... [Note: explicit constructor CALLS do not yield lvalues, see 3.10].
And so on.

Feel free to CALL it anything you like.

But don't feed claims about constructors being non-callable to the newsgroup.

Even with your quibbling over "is called" verses "calling"
your answer is WRONG. There are two DISTINCT steps in object
creation specifically listed in the standard:

1. First storage is obtained
2. Then construction occurs.

Your incorrect answer totally omits the first step.

"Create" can be subdivided, and further prerequisites added, so what?

I applaud the insight you've had that there must be some storage.

On the other hand, logic is otherwise totally absent in your reply; in
particular, I did not omit or include any details about creation other
than the need for a constructor call (in the cases of the only reasonable
interpretation of "object" in the question at hand).