Copy Constructor for an Array Element ???

[Peter Olcott]

//
// Is there something wrong with my syntax for the
// Copy Constructor of an Array Element, or does
// the C++ language not support this?
//

#include <stdio.h>
#include <stdlib.h>

class X {
int Data;
public:
X() { Data = 56; };
X(const X& Y) { Data = Y.Data; }; // Copy Constructor
void Construct(const X& Y) { Data = Y.Data; };
};

int main()
{
X ABC;
X* Temp = (X*) malloc(sizeof(X ) * 10);
for (int N = 0; N < 10; N++) {
// Temp[N].(ABC); // Does Not Compile
// Temp[N](ABC); // Does Not Compile
Temp[N].Construct(ABC) ; // Compiles and Executes Correctly
}
free(Temp);
return 0;
}

[Victor Bazarov]

"Peter Olcott" <ol****@worldne t.att.net> wrote...

//
// Is there something wrong with my syntax for the
// Copy Constructor of an Array Element, or does
// the C++ language not support this?
The latter. Constructors do not have names, therefore they cannot
be found during name lookup and hence cannot be _called_. They can
only be _invoked_ during construction of the object.

Given this situation, you'd be better off using _placement_new_
(read about it in a good C++ book).
//

#include <stdio.h>
#include <stdlib.h>

class X {
int Data;
public:
X() { Data = 56; };
X(const X& Y) { Data = Y.Data; }; // Copy Constructor
void Construct(const X& Y) { Data = Y.Data; };
};

int main()
{
X ABC;
X* Temp = (X*) malloc(sizeof(X ) * 10);
for (int N = 0; N < 10; N++) {
// Temp[N].(ABC); // Does Not Compile
// Temp[N](ABC); // Does Not Compile
Temp[N].Construct(ABC) ; // Compiles and Executes Correctly
}
free(Temp);
return 0;
}

V

[Jonathan Turkanis]

"Victor Bazarov" <v.********@com Acast.net> wrote in message:

"Peter Olcott" <ol****@worldne t.att.net> wrote...

//
// Is there something wrong with my syntax for the
// Copy Constructor of an Array Element, or does
// the C++ language not support this?

The latter. Constructors do not have names, therefore they cannot
be found during name lookup and hence cannot be _called_. They can
only be _invoked_ during construction of the object.

Given this situation, you'd be better off using _placement_new_
(read about it in a good C++ book).

I'd recommend using an assignment operator or a member function assign
(like std library containers) instead of placement new, unless you are
absolutely sure you need it.

And if you do use placement new to constuct an object on top of an
existing object, make sure to call the objects destructor first
(unless you are absolutely sure it's not necessary.)

Jonathan

[E. Robert Tisdale]

Peter Olcott wrote:

//
// Is there something wrong with my syntax for the
// Copy Constructor of an Array Element, or does
// the C++ language not support this?
//

#include <stdio.h>
#include <stdlib.h>

class X { private:
// representation int Data;
public:
X(void): Data(56) { } // default
X(const X& Y): Data(Y.Data) { } // Copy Constructor
// void Construct(const X& Y) { Data = Y.Data; }; // too late. *this already constructed
X& modify(const X& Y) { Data = Y.Data; return *this; } };

int main(int argc, char* argv[]) {
X ABC;
X* Temp = (X*)malloc(size of(X)*10); // you shouldn't do this
for (int N = 0; N < 10; ++N) { Temp[N] = ABC; // uses default assignment
Temp[N].modify(ABC); }
free(Temp);
return 0;
}

[Peter Olcott]

> I'd recommend using an assignment operator or a member function assign

(like std library containers) instead of placement new, unless you are
absolutely sure you need it.
I just created a std::vector class for antique (pre-template) C++ compilers.
My intention was to implement this within minimal execution time.
Apparently, it seems that even the modern std::vectors must use a kludge
to initialize their members. They seem to require default construction and
then assignment, rather than the single integrated step of copy construction.
Hopefully this shortcoming will by addressed in the continuing evolution
of C++.
And if you do use placement new to constuct an object on top of an
existing object, make sure to call the objects destructor first
(unless you are absolutely sure it's not necessary.)

Jonathan

[Cy Edmunds]

"Peter Olcott" <ol****@worldne t.att.net> wrote in message
news:ZP******** ************@bg tnsc05-news.ops.worldn et.att.net...

I'd recommend using an assignment operator or a member function assign
(like std library containers) instead of placement new, unless you are
absolutely sure you need it.
I just created a std::vector class for antique (pre-template) C++

compilers. My intention was to implement this within minimal execution time.
Apparently, it seems that even the modern std::vectors must use a kludge
to initialize their members. They seem to require default construction and
then assignment, rather than the single integrated step of copy

construction.

[snip]

Well, not really:

std::vector<int > a;
a.reserve(3);
a.push_back(2);
a.push_back(4);
a.push_back(-2);

reserve just allocates enough space and a copy constructor is used for each
element. No default constructor and no assignment. The only inefficiency
that I know of is that the number of push_back's is counted.

[Peter Olcott]

> > class X {

private:
// representation

int Data;
public:
X(void): Data(56) { } // default
X(const X& Y): Data(Y.Data) { } // Copy Constructor
// void Construct(const X& Y) { Data = Y.Data; }; // too late. *this already constructed

I don't think so. I think that the example might be the only
way to copy construct array elements.
X& modify(const X& Y) { Data = Y.Data; return *this; }

};

int main(int argc, char* argv[]) {
X ABC;
X* Temp = (X*)malloc(size of(X)*10); // you shouldn't do this
for (int N = 0; N < 10; ++N) {

Temp[N] = ABC; // uses default assignment
Temp[N].modify(ABC);

}
free(Temp);
return 0;
}

[Peter Olcott]

> std::vector<int > a;

a.reserve(3);
a.push_back(2);
a.push_back(4);
a.push_back(-2);

reserve just allocates enough space and a copy constructor is used for each
element. No default constructor and no assignment. The only inefficiency
that I know of is that the number of push_back's is counted.

Try the same sort of example with a class that does memory allocation,
such that a deep copy (rather than bitwise) is required.

[Jonathan Turkanis]

"Peter Olcott" <ol****@worldne t.att.net> wrote in message
news:nf******** ************@bg tnsc05-news.ops.worldn et.att.net...

std::vector<int > a;
a.reserve(3);
a.push_back(2);
a.push_back(4);
a.push_back(-2);

reserve just allocates enough space and a copy constructor is used for each element. No default constructor and no assignment. The only inefficiency that I know of is that the number of push_back's is counted.
Try the same sort of example with a class that does memory

allocation, such that a deep copy (rather than bitwise) is required.

Cy is correct.A vector obtains unitialized memory from an allocator,
and initilizes each element, when appropriate, then initializes them
using copy constructors with placement new. A default constructor is
not even required to exist. (See 20.1.4).

Of course, if the copy constructor is expensive, then push_back will
be too. There's no way to avoid this.

Jonathan

[Jonathan Turkanis]

"Jonathan Turkanis" <te******@kanga roologic.com> wrote in message
news:c1******** *****@ID-216073.news.uni-berlin.de...

Cy is correct.A vector obtains unitialized memory from an allocator,
and initilizes each element, when appropriate, then initializes them
using copy constructors with placement new. A default constructor is

This came out garbled. It should say:

A vector obtains unitialized memory from an allocator, then initilizes
each element, when appropriate, using copy constructors with placement
new

Jonathan