Is it possible to pass a pointer to a constructor or a class definition
as argument to a function? Maybe in a way similar to passing function
pointers...?

The function should construct a number of objects using the given
constructor. The objects should all inherit from a base class.

It's not possible to pass actual objects, since it's not given on
beforehand, how many should be created.

Thanks,
Morten

Morten Lemvigh wrote:

> Is it possible to pass a pointer to a constructor or a class definition
> as argument to a function? Maybe in a way similar to passing function
> pointers...?

Not directly. The standard somewhat ominously says that constructors have no
names. As a consequence, I think, you cannot obtain a function pointer to a
constructor.

But you can write functions that construct objects. E.g.,

template < typename T >
T* create ( void ) {
return ( new T() );
}

template < typename T, typename Arg1 >
T* create ( Arg1 const & arg1 ) {
return ( new T ( arg1 ) );
}

...

Then you could pass &create<MyType,MyArg> as a function pointer. However,
the signature of that function would depend on the actual types used. Thus,
the receiving function might need to be a template

template < typename Creator >
void some_function ( Creator create ) {
}

In that case, you could go all the way and turn create into a full-fledged
functor:

template < typename T >
struct creator {
typedef T value_type;
typedef T* pointer;

pointer operator() ( void ) const {
return ( new T () );
}
};

Now, you can pass creator<MyType>().


> The function should construct a number of objects using the given
> constructor. The objects should all inherit from a base class.
>
> It's not possible to pass actual objects, since it's not given on
> beforehand, how many should be created.

Huh? So how would it be determined? Could you provide a little more
background?


Best

Kai-Uwe Bux

On Jan 18, 1:44 pm, jkherci...@gmx.net wrote:
> Morten Lemvigh wrote:
> > Is it possible to pass a pointer to a constructor or a class definition
> > as argument to a function? Maybe in a way similar to passing function
> > pointers...?

> Not directly. The standard somewhat ominously says that
> constructors have no names.

More to the point, there is no way in the standard of "calling a
constructor", period. All of the contexts where a constructor
is called also involve allocating memory for the object. If you
try to call the constructor through a pointer to a function, how
would the compiler know where (stack?, dynamically?) or how much
memory to allocate?

(I suppose one could claim that placement new just calls a
constructor. But from the language point of view, it's a new
expression, which calls an operator new() function to get the
necessary memory.)

--
James Kanze (GABI Software) 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

James Kanze wrote:

> On Jan 18, 1:44 pm, jkherci...@gmx.net wrote:
>> Morten Lemvigh wrote:
>> > Is it possible to pass a pointer to a constructor or a class definition
>> > as argument to a function? Maybe in a way similar to passing function
>> > pointers...?
>
>> Not directly. The standard somewhat ominously says that
>> constructors have no names.
>
> More to the point, there is no way in the standard of "calling a
> constructor", period.

There is also no way of "calling a function" either. All that there is,
according to the standard, is that a function call expression is evaluated
and in the course of the execution of that evaluation, a function will be
called (but sometimes more happens: in the case of virtual functions, there
might even be some mechanism involved behind the scenes to decide which
one).

Similarly, there are expressions whose evaluation involves the call of
constructors (and usually much more). In fact, there are several.

Despite this, I take the linguistic license to say that I call a function.
Also, I don't see a reason not to take the same linguistic license with
constructor calls.

But, actually, this terminological issue is not "more to the point" of the
OP.

> All of the contexts where a constructor
> is called also involve allocating memory for the object. If you
> try to call the constructor through a pointer to a function, how
> would the compiler know where (stack?, dynamically?) or how much
> memory to allocate?

This, on the other hand, is. However:

> (I suppose one could claim that placement new just calls a
> constructor. But from the language point of view, it's a new
> expression, which calls an operator new() function to get the
> necessary memory.)

Well, C++ just provides a very very roundabout way to call a constructor on
a given region in memory (object): you have to go through a new-expression
with the of a library provided new() function that just returns its
argument and does no allocation of its own. Given all those provisions in
place, evaluation of a placement new expression boils down to nothing more
than calling a constructor. (Very much like some function call expressions
boil down to nothing more than calling a function:-)


In any case, we need to know more from the OP. The creator objects I
suggestest, will not use placement new but allocate memory and return
pointers to the constructed objects. If the OP has different requirements,
he would need to tell us.


Best

Kai-Uwe Bux

On Jan 18, 3:11 pm, jkherci...@gmx.net wrote:
> James Kanze wrote:
> > On Jan 18, 1:44 pm, jkherci...@gmx.net wrote:
> >> Morten Lemvigh wrote:
> >> > Is it possible to pass a pointer to a constructor or a class definition
> >> > as argument to a function? Maybe in a way similar to passing function
> >> > pointers...?

> >> Not directly. The standard somewhat ominously says that
> >> constructors have no names.

> > More to the point, there is no way in the standard of "calling a
> > constructor", period.

> There is also no way of "calling a function" either. All that
> there is, according to the standard, is that a function call
> expression is evaluated and in the course of the execution of
> that evaluation, a function will be called (but sometimes more
> happens: in the case of virtual functions, there might even be
> some mechanism involved behind the scenes to decide which
> one).

And your point is? The standard speaks of a function call
operator, and a function call expression. The expression
evaluates the arguments and calls the function. (Which function
is called, of course, depends on the expression, and a number of
other things.)

The standard doesn't have a constructor call expression. It
speaks of calling the constructor in the context of other
operations, such as type conversions, declarations or a new
expression. And all of these other operations have additional
semantics associated with them, systematically.

> Similarly, there are expressions whose evaluation involves the
> call of constructors (and usually much more). In fact, there
> are several.

> Despite this, I take the linguistic license to say that I call
> a function. Also, I don't see a reason not to take the same
> linguistic license with constructor calls.

Why not? The standard doesn't. I don't either, because I
think precision of expression is important when talking about
something as precise as a computer language.

Of course, if you don't care about being understood, you can use
any terminology you want.

> But, actually, this terminological issue is not "more to the
> point" of the OP.

> > All of the contexts where a constructor is called also
> > involve allocating memory for the object. If you try to
> > call the constructor through a pointer to a function, how
> > would the compiler know where (stack?, dynamically?) or how
> > much memory to allocate?

> This, on the other hand, is. However:

> > (I suppose one could claim that placement new just calls a
> > constructor. But from the language point of view, it's a new
> > expression, which calls an operator new() function to get the
> > necessary memory.)

> Well, C++ just provides a very very roundabout way to call a
> constructor on a given region in memory (object): you have to
> go through a new-expression with the of a library
> provided new() function that just returns its argument and
> does no allocation of its own. Given all those provisions in
> place, evaluation of a placement new expression boils down to
> nothing more than calling a constructor. (Very much like some
> function call expressions boil down to nothing more than
> calling a function:-)

Except that C++ also makes a distinction between library and
language---as far as the language is concerned, it is just
another case of an new expression.

> In any case, we need to know more from the OP. The creator
> objects I suggestest, will not use placement new but allocate
> memory and return pointers to the constructed objects. If the
> OP has different requirements, he would need to tell us.

He asked why you can't take a pointer to a constructor, like you
could a pointer to any other function. One of the reasons, of
course (not the only one), is that it makes no sense. The only
thing you can do with a pointer to a function is call the
function. Since a constructor can't be called without some
additional context, there's no practical way to implement
through a pointer to a function.

One could imagine a "pointer to a constructor", which, when
called, would also allocate memory in some way. C++ doesn't
have such, however, and if it did, it wouldn't be compatible
with a pointer to a function.

--
James Kanze (GABI Software) 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

James Kanze wrote:
> [..] The only
> thing you can do with a pointer to a function is call the
> function. Since a constructor can't be called without some
> additional context, there's no practical way to implement
> through a pointer to a function.

Uh... You don't have to call a function once you got a pointer
to it. You may just as well compare two function pointers or
instantiate a template using the function pointer.

> [..]

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

James Kanze wrote:

> On Jan 18, 3:11 pm, jkherci...@gmx.net wrote:
>> James Kanze wrote:
>> > On Jan 18, 1:44 pm, jkherci...@gmx.net wrote:
>> >> Morten Lemvigh wrote:
>> >> > Is it possible to pass a pointer to a constructor or a class
>> >> > definition as argument to a function? Maybe in a way similar to
>> >> > passing function pointers...?
>
>> >> Not directly. The standard somewhat ominously says that
>> >> constructors have no names.
>
>> > More to the point, there is no way in the standard of "calling a
>> > constructor", period.
>
>> There is also no way of "calling a function" either. All that
>> there is, according to the standard, is that a function call
>> expression is evaluated and in the course of the execution of
>> that evaluation, a function will be called (but sometimes more
>> happens: in the case of virtual functions, there might even be
>> some mechanism involved behind the scenes to decide which
>> one).
>
> And your point is? The standard speaks of a function call
> operator, and a function call expression. The expression
> evaluates the arguments and calls the function. (Which function
> is called, of course, depends on the expression, and a number of
> other things.)
>
> The standard doesn't have a constructor call expression. It
> speaks of calling the constructor in the context of other
> operations, such as type conversions, declarations or a new
> expression. And all of these other operations have additional
> semantics associated with them, systematically.

I see that we agree on what the standard says.

>> Similarly, there are expressions whose evaluation involves the
>> call of constructors (and usually much more). In fact, there
>> are several.
>
>> Despite this, I take the linguistic license to say that I call
>> a function. Also, I don't see a reason not to take the same
>> linguistic license with constructor calls.
>
> Why not? The standard doesn't. I don't either, because I
> think precision of expression is important when talking about
> something as precise as a computer language.
>
> Of course, if you don't care about being understood, you can use
> any terminology you want.

I do not think that saying something like "here on line 27, I call the
function foo()" is misleading. That is why I take the linguistic license.
If you don't, I won't force you.


>> But, actually, this terminological issue is not "more to the
>> point" of the OP.
>
>> > All of the contexts where a constructor is called also
>> > involve allocating memory for the object. If you try to
>> > call the constructor through a pointer to a function, how
>> > would the compiler know where (stack?, dynamically?) or how
>> > much memory to allocate?
>
>> This, on the other hand, is. However:
>
>> > (I suppose one could claim that placement new just calls a
>> > constructor. But from the language point of view, it's a new
>> > expression, which calls an operator new() function to get the
>> > necessary memory.)
>
>> Well, C++ just provides a very very roundabout way to call a
>> constructor on a given region in memory (object): you have to
>> go through a new-expression with the of a library
>> provided new() function that just returns its argument and
>> does no allocation of its own. Given all those provisions in
>> place, evaluation of a placement new expression boils down to
>> nothing more than calling a constructor. (Very much like some
>> function call expressions boil down to nothing more than
>> calling a function:-)
>
> Except that C++ also makes a distinction between library and
> language---as far as the language is concerned, it is just
> another case of an new expression.

Yet another point of agreement: it is just an expression whose evaluation
entails nothing more than a constructor call.

>> In any case, we need to know more from the OP. The creator
>> objects I suggestest, will not use placement new but allocate
>> memory and return pointers to the constructed objects. If the
>> OP has different requirements, he would need to tell us.
>
> He asked why you can't take a pointer to a constructor, like you
> could a pointer to any other function.

No. What the OP asked is this:

Is it possible to pass a pointer to a constructor or a class definition
as argument to a function?

The OP was not interested in the reasons why you cannot take a pointer to a
constructor because he did not know that he could not (had he known that
the question he asked would be moot). Moreover, he provided some
(insufficient) background as to why he wants to pass such a constructor
pointer to the function:

The function should construct a number of objects using the given
constructor. The objects should all inherit from a base class.

It's not possible to pass actual objects, since it's not given on
beforehand, how many should be created.

None of this shows any interest in the reasons why you cannot obtain a
pointer to a constructor. Instead it indicates that the OP has some design
problem and that he would probably be interested in alternatives to the
constructor-pointer approach that (as the two of have pointed out) cannot
work directly.

> One of the reasons, of
> course (not the only one), is that it makes no sense. The only
> thing you can do with a pointer to a function is call the
> function.

Victor has already addressed that misconception. However from the context of
the OP it is morally clear that the OP actually wanted to call the
constructor.

> Since a constructor can't be called without some
> additional context, there's no practical way to implement
> through a pointer to a function.
>
> One could imagine a "pointer to a constructor", which, when
> called, would also allocate memory in some way. C++ doesn't
> have such, however, and if it did, it wouldn't be compatible
> with a pointer to a function.

You are just providing additional reason as to why we need to know more
about the underlying problem that the OP is trying to solve.


Best

Kai-Uwe Bux

Morten Lemvigh:

> Is it possible to pass a pointer to a constructor or a class definition
> as argument to a function? Maybe in a way similar to passing function
> pointers...?
>
> The function should construct a number of objects using the given
> constructor. The objects should all inherit from a base class.
>
> It's not possible to pass actual objects, since it's not given on
> beforehand, how many should be created.


Instead of a getting a pointer directly to the contructor, you can get the
address of a very small function which calls the constructor:

void Func(T *const p)
{
::new(p) T(whatever parameters);
}


--
Tomás Ó hÉilidhe