assignment of const class members

[hweekuan]

hi,

it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }
full compile error:
-------------------------
[16:34]:Macintosh:tmp 7+ g++ cpp.C
cpp.C: In member function 'A& A::operator=(const A&)':
cpp.C:4: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = A,
_Alloc = std::allocator<A>]'
cpp.C:12: instantiated from here
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

[hweekuan]

i found this code compiled fine, the only diff is the "const" keyword
in the variable u. strange.

1 #include <vector>
2
3 struct A {
4 A(const unsigned int a) : u(a) {}
5 private: unsigned int u;
6 };
7
8 int main () {
9
10 std::vector<A y;
11 y.push_back(A(2));
12 }

On Dec 21, 4:38*pm, [e-mail] wrote:

hi,

it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

code:
-------
* 1
* 2 #include <vector>
* 3
* 4 struct A {
* 5 * A(const unsigned int a) : u(a) { }
* 6 * private: const unsigned int u;
* 7 };
* 8
* 9 int main () {
*10
*11 * std::vector<A*y;
*12 * y.push_back(A(2));
*13 }

full compile error:
-------------------------
[16:34]:Macintosh:tmp 7+ g++ cpp.C
cpp.C: In member function 'A& A::operator=(const A&)':
cpp.C:4: * instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: * instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = A,
_Alloc = std::allocator<A>]'
cpp.C:12: * instantiated from here
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

[Salt_Peter]

On Dec 21, 3:38 am, [e-mail] wrote:

hi,

it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

[ snip ]

One of the requirements of containers such as std::vector is that its
elements be copyable and assigneable.
Your type has a const member, so default assignment fails (if you
think about it - thats safer and quite brilliant).
Solution: define your own op=(...) assuming that assigning that const
member is ok.

struct A
{
A(const unsigned a) : u(a) { }
A& operator=(const A& rhs)
{
if(&rhs == this) // self check!
return *this;
u = rhs.u;
return *this;
}
private:
unsigned u;
};

[Kira Yamato]

On 2007-12-21 03:38:33 -0500, hw******@yahoo.com said:

hi,

it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

You have a number of problems with this code.

First, when (12) is executed, std::vector tries to allocate an array of
struct A. Unfortunately, struct A has no default constructor. So, it
cannot construct each element in the array.

Second, std::vector will then try to assign A(2) to one of the
available entry in the newly allocated array. Unfortunately, you did
not provide an assignment operator, so the default one kicks in.
Furthermore unfortunate, the default assignment operator tries to copy
the const member u, and you cannot change const members. This is the
error message you are seeing below.

>

full compile error:
-------------------------
[16:34]:Macintosh:tmp 7+ g++ cpp.C
cpp.C: In member function 'A& A::operator=(const A&)':
cpp.C:4: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = A,
_Alloc = std::allocator<A>]'
cpp.C:12: instantiated from here
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

--

-kira

[Salt_Peter]

On Dec 21, 4:47 am, Kira Yamato <[e-mail]:

On 2007-12-21 03:38:33 -0500, [e-mail] said:

hi,

it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

You have a number of problems with this code.

First, when (12) is executed, std::vector tries to allocate an array of
struct A. Unfortunately, struct A has no default constructor. So, it
cannot construct each element in the array.

There is no array, he's trying to copy into the empty vector a single
element.
if he had written the following:
std::vector<A y(10);
only then would a default ctor be required.

>
Second, std::vector will then try to assign A(2) to one of the
available entry in the newly allocated array. Unfortunately, you did
not provide an assignment operator, so the default one kicks in.
Furthermore unfortunate, the default assignment operator tries to copy
the const member u, and you cannot change const members. This is the
error message you are seeing below.

>

full compile error:
-------------------------
[16:34]:Macintosh:tmp 7+ g++ cpp.C
cpp.C: In member function 'A& A::operator=(const A&)':
cpp.C:4: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = A,
_Alloc = std::allocator<A>]'
cpp.C:12: instantiated from here
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

--

-kira

[Tadeusz B. Kopec]

On Fri, 21 Dec 2007 01:38:09 -0800, Salt_Peter wrote:

On Dec 21, 3:38 am, [e-mail] wrote:

>hi,

it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why does
C++ or vector class not like this code? my g++ is: gcc version 4.0.1
(Apple Inc. build 5465). thanks for the help.

summary of compile error:
--------------------------------------- cpp.C:4: error: non-static
const member 'const unsigned int A::u', can't use default assignment
operator /usr/include/c++/4.0.0/bits/vector.tcc:260: warning:
synthesized method 'A& A::operator=(const A&)' first required here

code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { } 6 private: const unsigned
int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

[ snip ]

One of the requirements of containers such as std::vector is that its
elements be copyable and assigneable. Your type has a const member, so
default assignment fails (if you think about it - thats safer and quite
brilliant). Solution: define your own op=(...) assuming that assigning
that const member is ok.

In your code (below) the member isn't const any more. Assigning const
member isn't OK. If it ceases to be const you needn't define assignment
operator - generated one will do.

>
struct A
{
A(const unsigned a) : u(a) { }
A& operator=(const A& rhs)
{
if(&rhs == this) // self check!
return *this;
u = rhs.u;
return *this;
}
private:
unsigned u;
};

--
Tadeusz B. Kopec (tk****@NOSPAMPLEASElife.pl)
The trouble with being punctual is that nobody's there to appreciate it.
-- Franklin P. Jones

[Kira Yamato]

On 2007-12-21 11:46:31 -0500, Salt_Peter <pj*****@yahoo.comsaid:

On Dec 21, 4:47 am, Kira Yamato <[e-mail]:

>On 2007-12-21 03:38:33 -0500, [e-mail] said:

>>hi,

>>it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

>>summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

>>code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

You have a number of problems with this code.

First, when (12) is executed, std::vector tries to allocate an array of
struct A. Unfortunately, struct A has no default constructor. So, it
cannot construct each element in the array.

There is no array, he's trying to copy into the empty vector a single
element.

Preciously. So, before line (12) can assign the element A(2) into
std::vector, the program must invoke code to allocate an array first.

How else will std::vector<Astore A(12)?

if he had written the following:
std::vector<A y(10);
only then would a default ctor be required.

>>
Second, std::vector will then try to assign A(2) to one of the
available entry in the newly allocated array. Unfortunately, you did
not provide an assignment operator, so the default one kicks in.
Furthermore unfortunate, the default assignment operator tries to copy
the const member u, and you cannot change const members. This is the
error message you are seeing below.

>>

>>full compile error:
-------------------------
[16:34]:Macintosh:tmp 7+ g++ cpp.C
cpp.C: In member function 'A& A::operator=(const A&)':
cpp.C:4: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_itera tor<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = A,
_Alloc = std::allocator<A>]'
cpp.C:12: instantiated from here
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_itera tor<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
A, _Alloc = std::allocator<A>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

--

-kira

--

-kira

[Salt_Peter]

On Dec 21, 6:18 pm, Kira Yamato <[e-mail]:

On 2007-12-21 11:46:31 -0500, Salt_Peter <[e-mail]:

On Dec 21, 4:47 am, Kira Yamato <[e-mail]:

On 2007-12-21 03:38:33 -0500, [e-mail] said:

>hi,

>it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

>summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

>code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

You have a number of problems with this code.

First, when (12) is executed, std::vector tries to allocate an array of
struct A. Unfortunately, struct A has no default constructor. So, it
cannot construct each element in the array.

There is no array, he's trying to copy into the empty vector a single
element.

Preciously. So, before line (12) can assign the element A(2) into
std::vector, the program must invoke code to allocate an array first.

How else will std::vector<Astore A(12)?

There is no array in an empty vector. The vector is empty.
pushing back a parametized element requires no default construction
either.
As i already mentioned, to have a vector invoke a default ctor you
would have to tell it to do so.

std::vector< A v; // does not invoke any of A's ctors

std::vector< A v(10); // invokes A's default ctor + 10 copies

A vector is not an array.
Here is the proof:

#include <iostream>
#include <vector>

class A
{
int m_n;
public:
A() : m_n(0) { std::cout << "A()\n"; }
A(int n) : m_n(n) { std::cout << "A(int)\n"; }
A(const A& copy)
{
std::cout << "A(const A& copy)\n";
m_n = copy.m_n;
}
};

int main()
{
std::cout << "declaring an empty std::vector:\n";
std::vector< A v;
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "pushing an element:\n";
v.push_back( A(99) );
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "default constructing 10 elements:\n";
std::vector< A v2(10);
std::cout << "v2.size() = " << v2.size() << std::endl;
}

/*
declaring an empty std::vector:
v.size() = 0
pushing an element:
A(int)
A(const A& copy)
v.size() = 1
default constructing 10 elements:
A()
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
v2.size() = 10
*/

[Kira Yamato]

On 2007-12-21 20:05:00 -0500, Salt_Peter <pj*****@yahoo.comsaid:

On Dec 21, 6:18 pm, Kira Yamato <[e-mail]:

>On 2007-12-21 11:46:31 -0500, Salt_Peter <[e-mail]:

>>On Dec 21, 4:47 am, Kira Yamato <[e-mail]:
On 2007-12-21 03:38:33 -0500, [e-mail] said:

>>>>hi,

>>>>it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

>>>>summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

>>>>code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

>>>You have a number of problems with this code.

>>>First, when (12) is executed, std::vector tries to allocate an array of
struct A. Unfortunately, struct A has no default constructor. So, it
cannot construct each element in the array.

>>There is no array, he's trying to copy into the empty vector a single
element.

Preciously. So, before line (12) can assign the element A(2) into
std::vector, the program must invoke code to allocate an array first.

How else will std::vector<Astore A(12)?

There is no array in an empty vector. The vector is empty.
pushing back a parametized element requires no default construction
either.
As i already mentioned, to have a vector invoke a default ctor you
would have to tell it to do so.

std::vector< A v; // does not invoke any of A's ctors

std::vector< A v(10); // invokes A's default ctor + 10 copies

A vector is not an array.
Here is the proof:

#include <iostream>
#include <vector>

class A
{
int m_n;
public:
A() : m_n(0) { std::cout << "A()\n"; }
A(int n) : m_n(n) { std::cout << "A(int)\n"; }
A(const A& copy)
{
std::cout << "A(const A& copy)\n";
m_n = copy.m_n;
}
};

int main()
{
std::cout << "declaring an empty std::vector:\n";
std::vector< A v;
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "pushing an element:\n";
v.push_back( A(99) );
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "default constructing 10 elements:\n";
std::vector< A v2(10);
std::cout << "v2.size() = " << v2.size() << std::endl;
}

/*
declaring an empty std::vector:
v.size() = 0
pushing an element:
A(int)
A(const A& copy)
v.size() = 1
default constructing 10 elements:
A()
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
v2.size() = 10
*/

Indeed you're right! I had thought that the internal implementation of
std::vector<Twas with a pointer to an array of T's. Apparently, it
is a pointer to an array of T* instead.

It makes sense too. This way, you can push_back objects that do not
have default constructor.

Thanks for the correction.

--

-kira

[hweekuan]

hi,

i tried a copy constructor, but the problem persist.
1 #include <vector>
2 #include <iostream>
3
4 struct A {
5 A(const unsigned int a) : u(a) {}
6 unsigned int u;
7 };
8
9 struct B {
10 B(const unsigned int a) : u(a) {}
11 B(const B& b) :u(b.u) {std::cerr<<" copy "<<std::endl;}
12 const unsigned int u;
13 };
14
15 int main () {
16
17 std::vector<A p;
18 p.push_back(A(2)); // ok
19
20 B w(8); // ok
21 B x=w; // copy ok
22 B y(x); // copy ok
23 std::vector<B z;
24 z.push_back(B(2)); // error
25 }
t.C: In member function 'B& B::operator=(const B&)':
t.C:9: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = B,
_Alloc = std::allocator<B>]'
t.C:24: instantiated from here
t.C:9: error: non-static const member 'const unsigned int B::u', can't
use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'B& B::operator=(const B&)' first required here

On Dec 22, 9:47 am, Kira Yamato <[e-mail]:

On 2007-12-21 20:05:00 -0500, Salt_Peter <[e-mail]:

On Dec 21, 6:18 pm, Kira Yamato <[e-mail]:

On 2007-12-21 11:46:31 -0500, Salt_Peter <[e-mail]:

>On Dec 21, 4:47 am, Kira Yamato <[e-mail]:
On 2007-12-21 03:38:33 -0500, [e-mail] said:

>>>hi,

>>>it seems i can't assign the const variable u in class A, one way to
solve the problem may be to build a copy constructor. however, why
does C++ or vector class not like this code? my g++ is: gcc version
4.0.1 (Apple Inc. build 5465). thanks for the help.

>>>summary of compile error:
---------------------------------------
cpp.C:4: error: non-static const member 'const unsigned int A::u',
can't use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'A& A::operator=(const A&)' first required here

>>>code:
-------
1
2 #include <vector>
3
4 struct A {
5 A(const unsigned int a) : u(a) { }
6 private: const unsigned int u;
7 };
8
9 int main () {
10
11 std::vector<A y;
12 y.push_back(A(2));
13 }

>>You have a number of problems with this code.

>>First, when (12) is executed, std::vector tries to allocate an array of
struct A. Unfortunately, struct A has no default constructor. So, it
cannot construct each element in the array.

>There is no array, he's trying to copy into the empty vector a single
element.

Preciously. So, before line (12) can assign the element A(2) into
std::vector, the program must invoke code to allocate an array first.

How else will std::vector<Astore A(12)?

There is no array in an empty vector. The vector is empty.
pushing back a parametized element requires no default construction
either.
As i already mentioned, to have a vector invoke a default ctor you
would have to tell it to do so.

std::vector< A v; // does not invoke any of A's ctors

std::vector< A v(10); // invokes A's default ctor + 10 copies

A vector is not an array.
Here is the proof:

#include <iostream>
#include <vector>

class A
{
int m_n;
public:
A() : m_n(0) { std::cout << "A()\n"; }
A(int n) : m_n(n) { std::cout << "A(int)\n"; }
A(const A& copy)
{
std::cout << "A(const A& copy)\n";
m_n = copy.m_n;
}
};

int main()
{
std::cout << "declaring an empty std::vector:\n";
std::vector< A v;
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "pushing an element:\n";
v.push_back( A(99) );
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "default constructing 10 elements:\n";
std::vector< A v2(10);
std::cout << "v2.size() = " << v2.size() << std::endl;
}

/*
declaring an empty std::vector:
v.size() = 0
pushing an element:
A(int)
A(const A& copy)
v.size() = 1
default constructing 10 elements:
A()
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
v2.size() = 10
*/

Indeed you're right! I had thought that the internal implementation of
std::vector<Twas with a pointer to an array of T's. Apparently, it
is a pointer to an array of T* instead.

It makes sense too. This way, you can push_back objects that do not
have default constructor.

Thanks for the correction.

--

-kira

[Salt_Peter]

On Dec 22, 11:37 am, [e-mail] wrote:

hi,

[re-arranged inline...] Do NOT Top Post

>
1 #include <vector>
2 #include <iostream>
3
4 struct A {
5 A(const unsigned int a) : u(a) {}
6 unsigned int u;
7 };
8
9 struct B {
10 B(const unsigned int a) : u(a) {}
11 B(const B& b) :u(b.u) {std::cerr<<" copy "<<std::endl;}
12 const unsigned int u;
13 };
14
15 int main () {
16
17 std::vector<A p;
18 p.push_back(A(2)); // ok
19
20 B w(8); // ok
21 B x=w; // copy ok
22 B y(x); // copy ok
23 std::vector<B z;
24 z.push_back(B(2)); // error
25 }

t.C: In member function 'B& B::operator=(const B&)':
t.C:9: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = B,
_Alloc = std::allocator<B>]'
t.C:24: instantiated from here
t.C:9: error: non-static const member 'const unsigned int B::u', can't
use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'B& B::operator=(const B&)' first required here

On Dec 22, 9:47 am, Kira Yamato <[e-mail]:

On 2007-12-21 20:05:00 -0500, Salt_Peter <[e-mail]:

On Dec 21, 6:18 pm, Kira Yamato <[e-mail]:
>On 2007-12-21 11:46:31 -0500, Salt_Peter <[e-mail]:

>>On Dec 21, 4:47 am, Kira Yamato <[e-mail]:
>>>On 2007-12-21 03:38:33 -0500, [e-mail] said:

>>>>hi,

>>>>it seems i can't assign the const variable u in class A, one way to
>>>>solve the problem may be to build a copy constructor. however, why
>>>>does C++ or vector class not like this code? my g++ is: gcc version
>>>>4.0.1 (Apple Inc. build 5465). thanks for the help.

>>>>summary of compile error:
>>>>---------------------------------------
>>>>cpp.C:4: error: non-static const member 'const unsigned int A::u',
>>>>can't use default assignment operator
>>>>/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
>>>>method 'A& A::operator=(const A&)' first required here

>>>>code:
>>>>-------
>>>>1
>>>>2 #include <vector>
>>>>3
>>>>4 struct A {
>>>>5 A(const unsigned int a) : u(a) { }
>>>>6 private: const unsigned int u;
>>>>7 };
>>>>8
>>>>9 int main () {
>>>>10
>>>>11 std::vector<A y;
>>>>12 y.push_back(A(2));
>>>>13 }

>>>You have a number of problems with this code.

>>>First, when (12) is executed, std::vector tries to allocate an array of
>>>struct A. Unfortunately, struct A has no default constructor. So, it
>>>cannot construct each element in the array.

>>There is no array, he's trying to copy into the empty vector a single
>>element.

>Preciously. So, before line (12) can assign the element A(2) into
>std::vector, the program must invoke code to allocate an array first.

>How else will std::vector<Astore A(12)?

There is no array in an empty vector. The vector is empty.
pushing back a parametized element requires no default construction
either.
As i already mentioned, to have a vector invoke a default ctor you
would have to tell it to do so.

std::vector< A v; // does not invoke any of A's ctors

std::vector< A v(10); // invokes A's default ctor + 10 copies

A vector is not an array.
Here is the proof:

#include <iostream>
#include <vector>

class A
{
int m_n;
public:
A() : m_n(0) { std::cout << "A()\n"; }
A(int n) : m_n(n) { std::cout << "A(int)\n"; }
A(const A& copy)
{
std::cout << "A(const A& copy)\n";
m_n = copy.m_n;
}
};

int main()
{
std::cout << "declaring an empty std::vector:\n";
std::vector< A v;
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "pushing an element:\n";
v.push_back( A(99) );
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "default constructing 10 elements:\n";
std::vector< A v2(10);
std::cout << "v2.size() = " << v2.size() << std::endl;
}

/*
declaring an empty std::vector:
v.size() = 0
pushing an element:
A(int)
A(const A& copy)
v.size() = 1
default constructing 10 elements:
A()
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
v2.size() = 10
*/

i tried a copy constructor, but the problem persist.

a) Do not Top Post
b) try to reply to the appropriate message inline, help us help you
c) read the replies (it says you need op= and the compiler clearly
states that in error log too)
Ignore the compiler at your own peril

[hweekuan]

On Dec 23, 4:25*am, Salt_Peter <[e-mail]:

On Dec 22, 11:37 am, [e-mail] wrote:

hi,

[re-arranged inline...] Do NOT Top Post

* 1 #include <vector>
* 2 #include <iostream>
* 3
* 4 struct A {
* 5 * A(const unsigned int a) : u(a) {}
* 6 * unsigned int u;
* 7 };
* 8
* 9 struct B {
*10 * B(const unsigned int a) : u(a) {}
*11 * B(const B& b) :u(b.u) {std::cerr<<" copy "<<std::endl;}
*12 * const unsigned int u;
*13 };
*14
*15 int main () {
*16
*17 * std::vector<A*p;
*18 * p.push_back(A(2)); * *// ok
*19
*20 * B w(8); * * * * * * * // ok
*21 * B x=w; * * * * * * * *// copy ok
*22 * B y(x); * * * * * * * // copy ok
*23 * std::vector<B*z;
*24 * z.push_back(B(2)); * *// error
*25 }

t.C: In member function 'B& B::operator=(const B&)':
t.C:9: * instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: * instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = B,
_Alloc = std::allocator<B>]'
t.C:24: * instantiated from here
t.C:9: error: non-static const member 'const unsigned int B::u', can't
use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'B& B::operator=(const B&)' first required here

On Dec 22, 9:47 am, Kira Yamato <[e-mail]:

On 2007-12-21 20:05:00 -0500, Salt_Peter <[e-mail]:

On Dec 21, 6:18 pm, Kira Yamato <[e-mail]:
On 2007-12-21 11:46:31 -0500, Salt_Peter <[e-mail]:

>On Dec 21, 4:47 am, Kira Yamato <[e-mail]:
>>On 2007-12-21 03:38:33 -0500, [e-mail] said:

>>>hi,

>>>it seems i can't assign the const variable u in class A, one wayto
>>>solve the problem may be to build a copy constructor. however, why
>>>does C++ or vector class not like this code? my g++ is: gcc version
>>>4.0.1 (Apple Inc. build 5465). thanks for the help.

>>>summary of compile error:
>>>---------------------------------------
>>>cpp.C:4: error: non-static const member 'const unsigned int A::u',
>>>can't use default assignment operator
>>>/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
>>>method 'A& A::operator=(const A&)' first required here

>>>code:
>>>-------
>>>1
>>>2 #include <vector>
>>>3
>>>4 struct A {
>>>5 * A(const unsigned int a) : u(a) { }
>>>6 * private: const unsigned int u;
>>>7 };
>>>8
>>>9 int main () {
>>>10
>>>11 * std::vector<A*y;
>>>12 * y.push_back(A(2));
>>>13 }

>>You have a number of problems with this code.

>>First, when (12) is executed, std::vector tries to allocate an array of
>>struct A. *Unfortunately, struct A has no default constructor. *So, it
>>cannot construct each element in the array.

>There is no array, he's trying to copy into the empty vector a single
>element.

Preciously. *So, before line (12) can assign the element A(2) into
std::vector, the program must invoke code to allocate an array first.

How else will std::vector<Astore A(12)?

There is no array in an empty vector. The vector is empty.
pushing back a parametized element requires no default construction
either.
As i already mentioned, to have a vector invoke a default ctor you
would have to tell it to do so.

std::vector< A v; // does not invoke any of A's ctors

std::vector< A v(10); // invokes A's default ctor + 10 copies

A vector is not an array.
Here is the proof:

#include <iostream>
#include <vector>

class A
{
* int m_n;
public:
* A() : m_n(0) { std::cout << "A()\n"; }
* A(int n) : m_n(n) { std::cout << "A(int)\n"; }
* A(const A& copy)
* {
* * std::cout << "A(const A& copy)\n";
* * m_n = copy.m_n;
* }
};

int main()
{
* std::cout << "declaring an empty std::vector:\n";
* std::vector< A v;
* std::cout << "v.size() = " << v.size() << std::endl;

* std::cout << "pushing an element:\n";
* v.push_back( A(99) );
* std::cout << "v.size() = " << v.size() << std::endl;

* std::cout << "default constructing 10 elements:\n";
* std::vector< A v2(10);
* std::cout << "v2.size() = " << v2.size() << std::endl;
}

/*
declaring an empty std::vector:
v.size() = 0
pushing an element:
A(int)
A(const A& copy)
v.size() = 1
default constructing 10 elements:
A()
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
v2.size() = 10
*/

i tried a copy constructor, but the problem persist.

a) Do not Top Post
b) try to reply to the appropriate message inline, help us help you
c) read the replies (it says you need op= and the compiler clearly
states that in error log too)
Ignore the compiler at your own peril

hi,

thanks for the help.

i noticed the compiler's log, if i define op= then i can't make the
variable "u" constant, if i don't make "u" const, then i don't have a
problem in the first place. how do i go around this issue?

[Salt_Peter]

On Dec 23, 8:18 pm, [e-mail] wrote:

On Dec 23, 4:25 am, Salt_Peter <[e-mail]:

On Dec 22, 11:37 am, [e-mail] wrote:

hi,

[re-arranged inline...] Do NOT Top Post

1 #include <vector>
2 #include <iostream>
3
4 struct A {
5 A(const unsigned int a) : u(a) {}
6 unsigned int u;
7 };
8
9 struct B {
10 B(const unsigned int a) : u(a) {}
11 B(const B& b) :u(b.u) {std::cerr<<" copy "<<std::endl;}
12 const unsigned int u;
13 };
14
15 int main () {
16
17 std::vector<A p;
18 p.push_back(A(2)); // ok
19
20 B w(8); // ok
21 B x=w; // copy ok
22 B y(x); // copy ok
23 std::vector<B z;
24 z.push_back(B(2)); // error
25 }

t.C: In member function 'B& B::operator=(const B&)':
t.C:9: instantiated from 'void std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]'
/usr/include/c++/4.0.0/bits/stl_vector.h:610: instantiated from
'void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = B,
_Alloc = std::allocator<B>]'
t.C:24: instantiated from here
t.C:9: error: non-static const member 'const unsigned int B::u', can't
use default assignment operator
/usr/include/c++/4.0.0/bits/vector.tcc: In member function 'void
std::vector<_Tp,
_Alloc>::_M_insert_aux(__gnu_cxx::__normal_iterato r<typename
_Alloc::pointer, std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
B, _Alloc = std::allocator<B>]':
/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
method 'B& B::operator=(const B&)' first required here

On Dec 22, 9:47 am, Kira Yamato <[e-mail]:

On 2007-12-21 20:05:00 -0500, Salt_Peter <[e-mail]:

On Dec 21, 6:18 pm, Kira Yamato <[e-mail]:
>On 2007-12-21 11:46:31 -0500, Salt_Peter <[e-mail]:

>>On Dec 21, 4:47 am, Kira Yamato <[e-mail]:
>>>On 2007-12-21 03:38:33 -0500, [e-mail] said:

>>>>hi,

>>>>it seems i can't assign the const variable u in class A, one way to
>>>>solve the problem may be to build a copy constructor. however, why
>>>>does C++ or vector class not like this code? my g++ is: gcc version
>>>>4.0.1 (Apple Inc. build 5465). thanks for the help.

>>>>summary of compile error:
>>>>---------------------------------------
>>>>cpp.C:4: error: non-static const member 'const unsigned int A::u',
>>>>can't use default assignment operator
>>>>/usr/include/c++/4.0.0/bits/vector.tcc:260: warning: synthesized
>>>>method 'A& A::operator=(const A&)' first required here

>>>>code:
>>>>-------
>>>>1
>>>>2 #include <vector>
>>>>3
>>>>4 struct A {
>>>>5 A(const unsigned int a) : u(a) { }
>>>>6 private: const unsigned int u;
>>>>7 };
>>>>8
>>>>9 int main () {
>>>>10
>>>>11 std::vector<A y;
>>>>12 y.push_back(A(2));
>>>>13 }

>>>You have a number of problems with this code.

>>>First, when (12) is executed, std::vector tries to allocate an array of
>>>struct A. Unfortunately, struct A has no default constructor. So, it
>>>cannot construct each element in the array.

>>There is no array, he's trying to copy into the empty vector a single
>>element.

>Preciously. So, before line (12) can assign the element A(2) into
>std::vector, the program must invoke code to allocate an array first.

>How else will std::vector<Astore A(12)?

There is no array in an empty vector. The vector is empty.
pushing back a parametized element requires no default construction
either.
As i already mentioned, to have a vector invoke a default ctor you
would have to tell it to do so.

std::vector< A v; // does not invoke any of A's ctors

std::vector< A v(10); // invokes A's default ctor + 10 copies

A vector is not an array.
Here is the proof:

#include <iostream>
#include <vector>

class A
{
int m_n;
public:
A() : m_n(0) { std::cout << "A()\n"; }
A(int n) : m_n(n) { std::cout << "A(int)\n"; }
A(const A& copy)
{
std::cout << "A(const A& copy)\n";
m_n = copy.m_n;
}
};

int main()
{
std::cout << "declaring an empty std::vector:\n";
std::vector< A v;
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "pushing an element:\n";
v.push_back( A(99) );
std::cout << "v.size() = " << v.size() << std::endl;

std::cout << "default constructing 10 elements:\n";
std::vector< A v2(10);
std::cout << "v2.size() = " << v2.size() << std::endl;
}

/*
declaring an empty std::vector:
v.size() = 0
pushing an element:
A(int)
A(const A& copy)
v.size() = 1
default constructing 10 elements:
A()
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
A(const A& copy)
v2.size() = 10
*/

i tried a copy constructor, but the problem persist.

a) Do not Top Post
b) try to reply to the appropriate message inline, help us help you
c) read the replies (it says you need op= and the compiler clearly
states that in error log too)
Ignore the compiler at your own peril

hi,

thanks for the help.

i noticed the compiler's log, if i define op= then i can't make the
variable "u" constant, if i don't make "u" const, then i don't have a
problem in the first place. how do i go around this issue?

you can't make u constant, an instance of the type (as is) would not
be assigneable.
Such an object can't be stored by a std::vector.
Now, if you really insist - you could choose to not modify that member
on assignment.
Though that would be strange to say the least.

#include <iostream>

struct A
{
A(const unsigned a) : u(a) { }
A(const A& copy) : u(copy.u) { }
A& operator=(const A& rhs)
{
if(&rhs == this) // self check!
return *this;
// do stuff, can't modify u
return *this;
}
unsigned get() const { return u; }
private:
const unsigned u;
};

int main()
{
A a(99); // ctor
A another = a; // copy
a = another; // assignment, ok
std::cout << a.get() << std::endl;
}

___

As far as a non-constant member u is concerned:
Since member u is private and an accessor would probably look like
get() above, that should keep that member safe from being modified
unintentionally.

A::get() const
{
return u;
}

So the following fails:

A a;
a.get() = 4; // error, can't modify non-constant u