wonder about constructors?

[Tom]

I was reading Bjourne's book and wonder about constructors?

If I have a class

template<class T> class Vector {
public:
explicit Vector(size_t n);
}

Does a default constructor get generated by the compiler?

[Jonathan Mcdougall]

Tom wrote:

I was reading Bjourne's book and wonder about constructors?

If I have a class

template<class T> class Vector {
public:
explicit Vector(size_t n);
}

Does a default constructor get generated by the compiler?

No.

int main()
{
Vector<int> v; // illegal
}

Note that "explicit" has nothing to do with it.
Jonathan

[Rolf Magnus]

Tom wrote:

I was reading Bjourne's book and wonder about constructors?

If I have a class

template<class T> class Vector {
public:
explicit Vector(size_t n);
}

Does a default constructor get generated by the compiler?

No. Whenever you define any constructor for a class (or class template), the
compiler will not generate a default constructor for it.

[Salt_Peter]

"Tom" <[e-mail]> wrote in message
news:01c68751$fb7cd200$0b01a8c0@n56l987...
| I was reading Bjourne's book and wonder about constructors?
|
| If I have a class
|
| template<class T> class Vector {
| public:
| explicit Vector(size_t n);
| }

semicolon missing

|
| Does a default constructor get generated by the compiler?

No, but whats preventing you from providing one? Why should the compiler be
allowed to guess about your needs and requirements? Same goes for both the
copy ctor and the assignment operator as well.

#include <vector>

template< typename T >
class Vector
{
std::vector< T > vt;
public:
Vector() : vt() { }
Vector(unsigned sz) : vt(sz) { }
~Vector() { }
};

[Rolf Magnus]

Salt_Peter wrote:

"Tom" <[e-mail]> wrote in message
news:01c68751$fb7cd200$0b01a8c0@n56l987...
| I was reading Bjourne's book and wonder about constructors?
|
| If I have a class
|
| template<class T> class Vector {
| public:
| explicit Vector(size_t n);
| }

semicolon missing

|
| Does a default constructor get generated by the compiler?

No, but whats preventing you from providing one? Why should the compiler
be allowed to guess about your needs and requirements?
Because it does that too if you don't define your own constructor.
Same goes for both the copy ctor and the assignment operator as well.

They are different. The default constructor won't be generated by the
compiler if you define _any_ constructor. The others will _always_ be
there, no matter what you define or don't define.

[Richard Herring]

In message <e5*************@news.t-online.com>, Rolf Magnus
<ra******@t-online.de> writes

Salt_Peter wrote:

"Tom" <[e-mail]> wrote in message
news:01c68751$fb7cd200$0b01a8c0@n56l987...
| I was reading Bjourne's book and wonder about constructors?
|
| If I have a class
|
| template<class T> class Vector {
| public:
| explicit Vector(size_t n);
| }

semicolon missing

|
| Does a default constructor get generated by the compiler?

No, but whats preventing you from providing one? Why should the compiler
be allowed to guess about your needs and requirements?

Because it does that too if you don't define your own constructor.

Same goes for both the copy ctor and the assignment operator as well.

They are different. The default constructor won't be generated by the
compiler if you define _any_ constructor. The others will _always_ be
there, no matter what you define or don't define.

Moreover, whenever it makes sense semantically it's _better_ to let the
compiler generate them than do it yourself, since the compiler won't
forget to initialise or assign every member, but the programmer might.

#include <vector>
template< typename T >
class Vector
{
std::vector< T > vt;
public:
Vector() : vt() { }
Pointless.
Vector(unsigned sz) : vt(sz) { }
What if std::vector::size_type is larger than unsigned?
~Vector() { }
Pointless.
};

--
Richard Herring

[Ron Natalie]

Richard Herring wrote:

Moreover, whenever it makes sense semantically it's _better_ to let the
compiler generate them than do it yourself, since the compiler won't
forget to initialise or assign every member, but the programmer might.

The copy constructor and copy-assignment operators are one thing,
but pray tell me what the "compiler generated default constructor"
is really doing for you?

The stupidity of C++ is that certain types have busted default
initialization (not so much that default initialization is busted
but the stupid language doesn't require it to be performed in
all cases).

[osmium]

"Ron Natalie" wrotes:

Moreover, whenever it makes sense semantically it's _better_ to let the
compiler generate them than do it yourself, since the compiler won't
forget to initialise or assign every member, but the programmer might.

The copy constructor and copy-assignment operators are one thing,
but pray tell me what the "compiler generated default constructor"
is really doing for you?

The stupidity of C++ is that certain types have busted default
initialization (not so much that default initialization is busted
but the stupid language doesn't require it to be performed in
all cases).

I think the thing that is broken is the terminology. A "constructor" sounds
like a funny name for a function that does something or other, presumably
something one wants done for him. For an ordinary class, the default ctor
does the same thing as is done when an int is declared, that is, nothing.
Space is allocated and that is the sum total of what happens. So C++ grants
a special name to a nonentity.

[Gavin Deane]

Rolf Magnus wrote:

Tom wrote:

I was reading Bjourne's book and wonder about constructors?

If I have a class

template<class T> class Vector {
public:
explicit Vector(size_t n);
}

Does a default constructor get generated by the compiler?

No. Whenever you define any constructor for a class (or class template), the
compiler will not generate a default constructor for it.

Whenever you declare, rather than define, any constructor ...

The most obvious example of declaring but not defining a constructor
that springs to mind is disabling copying by declaring the copy
constructor (and assignment operator, but that has no effect either way
on the compiler generated default constructor) private.

// Don't need any special initialisation so I'll
// rely on the compiler generated default constructor
class foo
{
public:
// stuff (but no constructors) ...
private:
// Disable copying
// No definition is provided anywhere for these two
foo(const foo&);
foo& operator=(const foo&);

// other stuff (but no constructors) ...
};

int main()
{
foo f; // Error: no default constructor available
}

Gavin Deane