Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Problem with copy constructor (a bit long story...)

Reply
Thread Tools

Problem with copy constructor (a bit long story...)

 
 
Jeroen
Guest
Posts: n/a
 
      04-24-2007
Hi all,

I'm trying to implement a certain class but I have problems regarding
the copy ctor. I'll try to explain this as good as possible and show
what I tried thusfar. Because it's not about a certain code syntax but
more a 'code architecture' thing , I'll use simple example classes
(which are certainly not complete or working...) just to illustrate the
idea (and I may make some mistakes because I'm not that experienced...).

The basic idea is that I have a class which has a data vector, but
objects of that class can also share that data vector between several
instances:

class A {
vector<double> *data; // pointer, so objects of 'A' can _share_ data.
bool data_is_shared; // does this 'A' share data with another A?

A(const bool do_data_init=true); // ctor
A(const A& a); // copy constructor
A get_shared_A(); // get an object A which shares 'this' data
};

Ctor:

A::A(bool do_data_init)
{
if (do_data_init)
data = new vector<double>;
data_is_shared = !do_data_init;
}

Copy ctor, always result in an 'A' which does not share data:

A::A(const A& a)
{
data = new vector<double>;
data_is_shared = false;
*data = *a.data;
}

Get an object A which shares data with 'this':

A A::get_shared_A()
{
A a(false);

a.data = data; // copy the data pointer only
return a;
}

The problems focus on this last method 'get_shared_A'. It should return
an object A that shares its data with 'this'. Problem: on returning 'a',
the copy constructor _may_ be called and then an object A is returned
which has its own data vector. So this doesn't work... I cannot change
the copy ctor because that should always return an A which does not
share its data (that's a requirement for correct behaviour of class A).

In my application, 'get_shared_A' is an operator which selects a part of
the original data in 'this', and the returned result must be an object A
because it must be used in mathematical expressions just like all other A's.

So, using a 'helper'-class B I tried to change this in:

A A::get_shared_A()
{
B b;

b.data = data; // copy the data pointer only
return b;
}

With class B:

class B {
vector<double> *data;
};

And an extra conversion ctor for A:

A::A(const& B b)
{
data = b.data;
data_is_shared = true;
}

So I wanted the code to force to use this new ctor and return an object
A which shares its data. But again, after the conversion ctor is called
it is still possible that the copy ctor is also called and things do not
work correctly.

In fact, all possible solutions I came up with do not work because you
cannot be sure if the copy ctor is called when returning from
'get_shared_A', it depends on the compiler you have.

So, does anybody has any ideas to overcome this problem?

Jeroen
 
Reply With Quote
 
 
 
 
Alf P. Steinbach
Guest
Posts: n/a
 
      04-24-2007
* Jeroen:
>
> The basic idea is that I have a class which has a data vector, but
> objects of that class can also share that data vector between several
> instances:


Use boost::shared_ptr to implement the sharing. If you want a
non-shared copy provide that via some member function. Not via the copy
constructor.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
 
Reply With Quote
 
 
 
 
Jeroen
Guest
Posts: n/a
 
      04-24-2007
Alf P. Steinbach schreef:
> * Jeroen:
>>
>> The basic idea is that I have a class which has a data vector, but
>> objects of that class can also share that data vector between several
>> instances:

>
> Use boost::shared_ptr to implement the sharing. If you want a
> non-shared copy provide that via some member function. Not via the copy
> constructor.
>


That may just be the problem. The library in which class A resides uses
the concept of shared data and so on. But for the user all of this is
not available, nor visible. The user expects 'normal' behaviour of class
A. So if a user of the library uses a subscript operator in order to
select a portion of the data in an object A and directly uses that as a
parameter to a function, then the copy constructor is called which is
required to make a non data-sharing copy:

void user_function(A a)
{
a = 10; // parameter 'a' must be changed here, not the original data!
}

void other_user_function()
{
A a;
user_function(a("1:10")); // or whatever syntax I'l use here....
}

The code 'a("1:10")' results in an object of class A which shares its
data with its 'parent' (this was coded in my original post by method
'get_shared_A' in class A, but its an operator in fact), but the copy
constructor called for 'user_function' must create an A which does not
share its data in order to provide correct behaviour.

Given the above, I don't see the solution in your suggestion...

Jeroen
 
Reply With Quote
 
Alf P. Steinbach
Guest
Posts: n/a
 
      04-24-2007
* Jeroen:
> Alf P. Steinbach schreef:
>> * Jeroen:
>>>
>>> The basic idea is that I have a class which has a data vector, but
>>> objects of that class can also share that data vector between several
>>> instances:

>>
>> Use boost::shared_ptr to implement the sharing. If you want a
>> non-shared copy provide that via some member function. Not via the
>> copy constructor.
>>

>
> That may just be the problem. The library in which class A resides uses
> the concept of shared data and so on. But for the user all of this is
> not available, nor visible. The user expects 'normal' behaviour of class
> A. So if a user of the library uses a subscript operator in order to
> select a portion of the data in an object A and directly uses that as a
> parameter to a function, then the copy constructor is called which is
> required to make a non data-sharing copy:
>
> void user_function(A a)
> {
> a = 10; // parameter 'a' must be changed here, not the original data!
> }
>
> void other_user_function()
> {
> A a;
> user_function(a("1:10")); // or whatever syntax I'l use here....
> }
>
> The code 'a("1:10")' results in an object of class A which shares its
> data with its 'parent' (this was coded in my original post by method
> 'get_shared_A' in class A, but its an operator in fact), but the copy
> constructor called for 'user_function' must create an A which does not
> share its data in order to provide correct behaviour.
>
> Given the above, I don't see the solution in your suggestion...


Not to put to fine words on it, you're confused. You want a copy
constructor that has two incompatible properties: making a non-shared
copy (only), and making a shared copy (only). If the sharing, as you
write above, is an implementation detail, then try to define exactly
what it's meant to accomplish; e.g. it may be that what you're trying to
achieve is some copy-on-write scheme, in which case do as I wrote.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
 
Reply With Quote
 
Jeroen
Guest
Posts: n/a
 
      04-24-2007
Alf P. Steinbach schreef:
> * Jeroen:
>> Alf P. Steinbach schreef:
>>> * Jeroen:
>>>>
>>>> The basic idea is that I have a class which has a data vector, but
>>>> objects of that class can also share that data vector between
>>>> several instances:
>>>
>>> Use boost::shared_ptr to implement the sharing. If you want a
>>> non-shared copy provide that via some member function. Not via the
>>> copy constructor.
>>>

>>
>> That may just be the problem. The library in which class A resides
>> uses the concept of shared data and so on. But for the user all of
>> this is not available, nor visible. The user expects 'normal'
>> behaviour of class A. So if a user of the library uses a subscript
>> operator in order to select a portion of the data in an object A and
>> directly uses that as a parameter to a function, then the copy
>> constructor is called which is required to make a non data-sharing copy:
>>
>> void user_function(A a)
>> {
>> a = 10; // parameter 'a' must be changed here, not the original data!
>> }
>>
>> void other_user_function()
>> {
>> A a;
>> user_function(a("1:10")); // or whatever syntax I'l use here....
>> }
>>
>> The code 'a("1:10")' results in an object of class A which shares its
>> data with its 'parent' (this was coded in my original post by method
>> 'get_shared_A' in class A, but its an operator in fact), but the copy
>> constructor called for 'user_function' must create an A which does not
>> share its data in order to provide correct behaviour.
>>
>> Given the above, I don't see the solution in your suggestion...

>
> Not to put to fine words on it, you're confused. You want a copy
> constructor that has two incompatible properties: making a non-shared
> copy (only), and making a shared copy (only). If the sharing, as you
> write above, is an implementation detail, then try to define exactly
> what it's meant to accomplish; e.g. it may be that what you're trying to
> achieve is some copy-on-write scheme, in which case do as I wrote.
>


As I think things over, I see more problems on the horizon But I
will certainly take a good look on boost::shared_ptr. Thanks for replying !
 
Reply With Quote
 
=?ISO-8859-1?Q?Erik_Wikstr=F6m?=
Guest
Posts: n/a
 
      04-24-2007
On 2007-04-24 10:49, Jeroen wrote:
> Hi all,
>
> I'm trying to implement a certain class but I have problems regarding
> the copy ctor. I'll try to explain this as good as possible and show
> what I tried thusfar. Because it's not about a certain code syntax but
> more a 'code architecture' thing , I'll use simple example classes
> (which are certainly not complete or working...) just to illustrate the
> idea (and I may make some mistakes because I'm not that experienced...).
>
> The basic idea is that I have a class which has a data vector, but
> objects of that class can also share that data vector between several
> instances:
>
> class A {
> vector<double> *data; // pointer, so objects of 'A' can _share_ data.
> bool data_is_shared; // does this 'A' share data with another A?
>
> A(const bool do_data_init=true); // ctor
> A(const A& a); // copy constructor
> A get_shared_A(); // get an object A which shares 'this' data
> };
>
> Ctor:
>
> A::A(bool do_data_init)
> {
> if (do_data_init)
> data = new vector<double>;
> data_is_shared = !do_data_init;
> }
>
> Copy ctor, always result in an 'A' which does not share data:
>
> A::A(const A& a)
> {
> data = new vector<double>;
> data_is_shared = false;
> *data = *a.data;
> }
>
> Get an object A which shares data with 'this':
>
> A A::get_shared_A()
> {
> A a(false);
>
> a.data = data; // copy the data pointer only
> return a;
> }
>
> The problems focus on this last method 'get_shared_A'. It should return
> an object A that shares its data with 'this'. Problem: on returning 'a',
> the copy constructor _may_ be called and then an object A is returned
> which has its own data vector. So this doesn't work... I cannot change
> the copy ctor because that should always return an A which does not
> share its data (that's a requirement for correct behaviour of class A).
>
> In my application, 'get_shared_A' is an operator which selects a part of
> the original data in 'this', and the returned result must be an object A
> because it must be used in mathematical expressions just like all other A's.
>
> So, using a 'helper'-class B I tried to change this in:
>
> A A::get_shared_A()
> {
> B b;
>
> b.data = data; // copy the data pointer only
> return b;
> }
>
> With class B:
>
> class B {
> vector<double> *data;
> };
>
> And an extra conversion ctor for A:
>
> A::A(const& B b)
> {
> data = b.data;
> data_is_shared = true;
> }
>
> So I wanted the code to force to use this new ctor and return an object
> A which shares its data. But again, after the conversion ctor is called
> it is still possible that the copy ctor is also called and things do not
> work correctly.
>
> In fact, all possible solutions I came up with do not work because you
> cannot be sure if the copy ctor is called when returning from
> 'get_shared_A', it depends on the compiler you have.
>
> So, does anybody has any ideas to overcome this problem?


Some time a go (Qt3) I took a look at the implicit sharing mechanism of
QList, the idea is that if you do something like this:

QList a;
/* add elements to a */
QList b = a;

then b will share the elements with a until one of them makes any
changes to the list, at which point it will "detach" (which basically
means that it will create a copy of the list and make the changes to the
copy).

If I understood your problem correctly it's quite similar but the other
way around, you want explicit sharing, but the idea should still be the
same and if you understand how they did it in Qt you should be able to
make it work for you (unless you need it to be thread-safe, at which
point it becomes a bit more tricky).

--
Erik Wikström
 
Reply With Quote
 
MathWizard
Guest
Posts: n/a
 
      04-24-2007
Erik Wikström wrote:

> On 2007-04-24 10:49, Jeroen wrote:
>
>> Hi all,
>>
>> I'm trying to implement a certain class but I have problems regarding
>> the copy ctor. I'll try to explain this as good as possible and show
>> what I tried thusfar. Because it's not about a certain code syntax
>> but more a 'code architecture' thing , I'll use simple example
>> classes (which are certainly not complete or working...) just to
>> illustrate the idea (and I may make some mistakes because I'm not
>> that experienced...).
>>
>> The basic idea is that I have a class which has a data vector, but
>> objects of that class can also share that data vector between several
>> instances:
>>
>> class A {
>> vector<double> *data; // pointer, so objects of 'A' can _share_ data.
>> bool data_is_shared; // does this 'A' share data with another A?
>>
>> A(const bool do_data_init=true); // ctor
>> A(const A& a); // copy constructor
>> A get_shared_A(); // get an object A which shares 'this' data
>> };
>>
>> Ctor:
>>
>> A::A(bool do_data_init)
>> {
>> if (do_data_init)
>> data = new vector<double>;
>> data_is_shared = !do_data_init;
>> }
>>
>> Copy ctor, always result in an 'A' which does not share data:
>>
>> A::A(const A& a)
>> {
>> data = new vector<double>;
>> data_is_shared = false;
>> *data = *a.data;
>> }
>>
>> Get an object A which shares data with 'this':
>>
>> A A::get_shared_A()
>> {
>> A a(false);
>>
>> a.data = data; // copy the data pointer only
>> return a;
>> }
>>
>> The problems focus on this last method 'get_shared_A'. It should
>> return an object A that shares its data with 'this'. Problem: on
>> returning 'a', the copy constructor _may_ be called and then an
>> object A is returned which has its own data vector. So this doesn't
>> work... I cannot change the copy ctor because that should always
>> return an A which does not share its data (that's a requirement for
>> correct behaviour of class A).
>>
>> In my application, 'get_shared_A' is an operator which selects a part
>> of the original data in 'this', and the returned result must be an
>> object A because it must be used in mathematical expressions just
>> like all other A's.
>>
>> So, using a 'helper'-class B I tried to change this in:
>>
>> A A::get_shared_A()
>> {
>> B b;
>>
>> b.data = data; // copy the data pointer only
>> return b;
>> }
>>
>> With class B:
>>
>> class B {
>> vector<double> *data;
>> };
>>
>> And an extra conversion ctor for A:
>>
>> A::A(const& B b)
>> {
>> data = b.data;
>> data_is_shared = true;
>> }
>>
>> So I wanted the code to force to use this new ctor and return an
>> object A which shares its data. But again, after the conversion ctor
>> is called it is still possible that the copy ctor is also called and
>> things do not work correctly.
>>
>> In fact, all possible solutions I came up with do not work because
>> you cannot be sure if the copy ctor is called when returning from
>> 'get_shared_A', it depends on the compiler you have.
>>
>> So, does anybody has any ideas to overcome this problem?

>
>
> Some time a go (Qt3) I took a look at the implicit sharing mechanism
> of QList, the idea is that if you do something like this:
>
> QList a;
> /* add elements to a */
> QList b = a;
>
> then b will share the elements with a until one of them makes any
> changes to the list, at which point it will "detach" (which basically
> means that it will create a copy of the list and make the changes to
> the copy).
>
> If I understood your problem correctly it's quite similar but the
> other way around, you want explicit sharing, but the idea should still
> be the same and if you understand how they did it in Qt you should be
> able to make it work for you (unless you need it to be thread-safe, at
> which point it becomes a bit more tricky).
>

OK, thanks for the pointer The problem that I came up with is a
little more 'sophisticated' than just sharing data. I try to implement a
matrix class which supports subscripting with a string, thus enabling to
'select' submatrices. For example:

matrix m(10,10); // 10x10 matrix
m("1:3,:") = 1; // rows 1 to 3 become '1'.

In this example, I use operator () for smart subscripting and this
operator must return a matrix object which only points to the selected
data range of its 'parent' matrix 'm' so it can be modified. Looks like
sharing data, but in this case I want the 'shared data' to be changed!

On the other hand, if you have a function (useless code by the way, but
just to illustrate things):

void my_function(matrix m)
{
m = 1;
}

and you call that by:

my_function(m("1:4,:"));

then my subscripting operator returns a matrix object which only points
to the selected data (this behaviour follows from the previous example),
but the copy constructor called when calling my_function must return a
matrix object which has its own data in order to prevent that the
original data is changed within my_function. But the copy ctor may
interfere within my operator () as I illustrated in my original post.

I'm at the point where I need to figure out all the functionality
required by correct matrix behaviour (the only thing I can come up with
is to generate as many possible situations like the previous examples),
and check if there isn't some inherent impossibility to make things
work.... Maybe this project is just too difficult for me

Jeroen
 
Reply With Quote
 
=?ISO-8859-1?Q?Erik_Wikstr=F6m?=
Guest
Posts: n/a
 
      04-24-2007
On 2007-04-24 21:14, MathWizard wrote:
> Erik Wikström wrote:
>
>> On 2007-04-24 10:49, Jeroen wrote:
>>
>>> Hi all,
>>>
>>> I'm trying to implement a certain class but I have problems regarding
>>> the copy ctor. I'll try to explain this as good as possible and show
>>> what I tried thusfar. Because it's not about a certain code syntax
>>> but more a 'code architecture' thing , I'll use simple example
>>> classes (which are certainly not complete or working...) just to
>>> illustrate the idea (and I may make some mistakes because I'm not
>>> that experienced...).
>>>
>>> The basic idea is that I have a class which has a data vector, but
>>> objects of that class can also share that data vector between several
>>> instances:
>>>
>>> class A {
>>> vector<double> *data; // pointer, so objects of 'A' can _share_ data.
>>> bool data_is_shared; // does this 'A' share data with another A?
>>>
>>> A(const bool do_data_init=true); // ctor
>>> A(const A& a); // copy constructor
>>> A get_shared_A(); // get an object A which shares 'this' data
>>> };
>>>
>>> Ctor:
>>>
>>> A::A(bool do_data_init)
>>> {
>>> if (do_data_init)
>>> data = new vector<double>;
>>> data_is_shared = !do_data_init;
>>> }
>>>
>>> Copy ctor, always result in an 'A' which does not share data:
>>>
>>> A::A(const A& a)
>>> {
>>> data = new vector<double>;
>>> data_is_shared = false;
>>> *data = *a.data;
>>> }
>>>
>>> Get an object A which shares data with 'this':
>>>
>>> A A::get_shared_A()
>>> {
>>> A a(false);
>>>
>>> a.data = data; // copy the data pointer only
>>> return a;
>>> }
>>>
>>> The problems focus on this last method 'get_shared_A'. It should
>>> return an object A that shares its data with 'this'. Problem: on
>>> returning 'a', the copy constructor _may_ be called and then an
>>> object A is returned which has its own data vector. So this doesn't
>>> work... I cannot change the copy ctor because that should always
>>> return an A which does not share its data (that's a requirement for
>>> correct behaviour of class A).
>>>
>>> In my application, 'get_shared_A' is an operator which selects a part
>>> of the original data in 'this', and the returned result must be an
>>> object A because it must be used in mathematical expressions just
>>> like all other A's.
>>>
>>> So, using a 'helper'-class B I tried to change this in:
>>>
>>> A A::get_shared_A()
>>> {
>>> B b;
>>>
>>> b.data = data; // copy the data pointer only
>>> return b;
>>> }
>>>
>>> With class B:
>>>
>>> class B {
>>> vector<double> *data;
>>> };
>>>
>>> And an extra conversion ctor for A:
>>>
>>> A::A(const& B b)
>>> {
>>> data = b.data;
>>> data_is_shared = true;
>>> }
>>>
>>> So I wanted the code to force to use this new ctor and return an
>>> object A which shares its data. But again, after the conversion ctor
>>> is called it is still possible that the copy ctor is also called and
>>> things do not work correctly.
>>>
>>> In fact, all possible solutions I came up with do not work because
>>> you cannot be sure if the copy ctor is called when returning from
>>> 'get_shared_A', it depends on the compiler you have.
>>>
>>> So, does anybody has any ideas to overcome this problem?

>>
>>
>> Some time a go (Qt3) I took a look at the implicit sharing mechanism
>> of QList, the idea is that if you do something like this:
>>
>> QList a;
>> /* add elements to a */
>> QList b = a;
>>
>> then b will share the elements with a until one of them makes any
>> changes to the list, at which point it will "detach" (which basically
>> means that it will create a copy of the list and make the changes to
>> the copy).
>>
>> If I understood your problem correctly it's quite similar but the
>> other way around, you want explicit sharing, but the idea should still
>> be the same and if you understand how they did it in Qt you should be
>> able to make it work for you (unless you need it to be thread-safe, at
>> which point it becomes a bit more tricky).
>>

> OK, thanks for the pointer The problem that I came up with is a
> little more 'sophisticated' than just sharing data. I try to implement a
> matrix class which supports subscripting with a string, thus enabling to
> 'select' submatrices. For example:
>
> matrix m(10,10); // 10x10 matrix
> m("1:3,:") = 1; // rows 1 to 3 become '1'.
>
> In this example, I use operator () for smart subscripting and this
> operator must return a matrix object which only points to the selected
> data range of its 'parent' matrix 'm' so it can be modified. Looks like
> sharing data, but in this case I want the 'shared data' to be changed!
>
> On the other hand, if you have a function (useless code by the way, but
> just to illustrate things):
>
> void my_function(matrix m)
> {
> m = 1;
> }
>
> and you call that by:
>
> my_function(m("1:4,:"));
>
> then my subscripting operator returns a matrix object which only points
> to the selected data (this behaviour follows from the previous example),
> but the copy constructor called when calling my_function must return a
> matrix object which has its own data in order to prevent that the
> original data is changed within my_function. But the copy ctor may
> interfere within my operator () as I illustrated in my original post.
>
> I'm at the point where I need to figure out all the functionality
> required by correct matrix behaviour (the only thing I can come up with
> is to generate as many possible situations like the previous examples),
> and check if there isn't some inherent impossibility to make things
> work.... Maybe this project is just too difficult for me


Sounds a bit like valarray and slice/slice_array, might be worth taking
a look at, if nothing else as an inspiration.

--
Erik Wikström
 
Reply With Quote
 
Mumia W.
Guest
Posts: n/a
 
      04-25-2007
On 04/24/2007 02:14 PM, MathWizard wrote:
> [...]
> On the other hand, if you have a function (useless code by the way, but
> just to illustrate things):
>
> void my_function(matrix m)
> {
> m = 1;
> }
>
> and you call that by:
>
> my_function(m("1:4,:"));
>
> then my subscripting operator returns a matrix object which only points
> to the selected data (this behaviour follows from the previous example),
> but the copy constructor called when calling my_function must return a
> matrix object which has its own data in order to prevent that the
> original data is changed within my_function. But the copy ctor may
> interfere within my operator () as I illustrated in my original post.
> [...]


You might be able to eliminate the copy-constructor call by making
my_function accept a reference:

void my_function (matrix & m) { ... }

 
Reply With Quote
 
Jeroen
Guest
Posts: n/a
 
      04-25-2007
Mumia W. schreef:
> On 04/24/2007 02:14 PM, MathWizard wrote:
>> [...]
>> On the other hand, if you have a function (useless code by the way,
>> but just to illustrate things):
>>
>> void my_function(matrix m)
>> {
>> m = 1;
>> }
>>
>> and you call that by:
>>
>> my_function(m("1:4,:"));
>>
>> then my subscripting operator returns a matrix object which only
>> points to the selected data (this behaviour follows from the previous
>> example), but the copy constructor called when calling my_function
>> must return a matrix object which has its own data in order to prevent
>> that the original data is changed within my_function. But the copy
>> ctor may interfere within my operator () as I illustrated in my
>> original post.
>> [...]

>
> You might be able to eliminate the copy-constructor call by making
> my_function accept a reference:
>
> void my_function (matrix & m) { ... }
>


That's not the problem because this works fine if I have a copy
constructor which always returns a non-sharing matrix object. The
problem lies within the operator () which I use for subscripting.
Because I do not know if a copy constructor is called on return (depends
on compiler), correct behaviour of my implementation is not guaranteed.

What I want is to differentiate between situations where a copy ctor is
called:

* if the copy ctor is called when calling a function (pass by value
parms), then a non-sharing matrix object must be created.
* if the copy ctor is called when returning a matrix object from a
function, then an exact copy must be made (sharing or non-sharing
characteristics are not changed by the copy).

That's seems to be impossible, so I think I have to come up with some
other mechanism to get it right....
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
template copy constructor vs normal copy constructor cinsk C++ 35 10-10-2010 11:14 PM
Having compilation error: no match for call to ‘(const __gnu_cxx::hash<long long int>) (const long long int&)’ veryhotsausage C++ 1 07-04-2008 05:41 PM
A constructor calling another constructor (default constructor)? Generic Usenet Account C++ 10 11-28-2007 04:12 AM
64 bit - Windows Liberty 64bit, Windows Limited Edition 64 Bit, Microsoft SQL Server 2000 Developer Edition 64 Bit, IBM DB2 64 bit - new ! vvcd Computer Support 0 09-17-2004 08:15 PM
64 bit - Windows Liberty 64bit, Windows Limited Edition 64 Bit,Microsoft SQL Server 2000 Developer Edition 64 Bit, IBM DB2 64 bit - new! Ionizer Computer Support 1 01-01-2004 07:27 PM



Advertisments