string s("Jumping Jack Flash");
string t(s); // definition with initialization by copying
string u = s; // definition with initialization by copying
stack<int> S;
// ... fill S with some elements
stack<int> T(S); // definition with initialization by copying
list_item it1, it2; // ... it2 = it1; // it2 now references the same container as it1
array<int> A, B; // ...fill A with some elements... B = A;
Now B contains the same number
of integers as A, in the same order,
with the same values.
However, A and B do not contain the same objects:
int* p = A[0]; int* q = B[0]; p == q; // false
A and B are different objects:
A == B; // false
list<int> L, M; list_item it1, it2; L.push(42); L.push(666); M = L;
L and M now
both contain the numbers 666 and 42. These numbers are
not the same objects:
it1 = L.first(); it2 = M.first(); it1 == it2; // false
L and M are
different objects as well:
L == M; // false
In the following assignment the rules c, b, and a are applied recursivley (in this order):
list< array<int> > L, M; // ...fill L with some array<int>s // each of them filled with some elements... M = L;
list_item it1, it2; // ... it2 = it1; // it2 now references the same container as it1 it1 == it2; // true
point p(2.0, 3.0); point q(2.0, 3.0); p == q; // true (as defined for class point) identical(p, q); // false point r; r = p; identical(p, r); // true
list<int> L, M; // ...fill L with some elements... M = L; L == M; // false
list_item it = L.first(); L.del_item(it); L.contents(it); // illegal access it = nil; L.contents(it); // illegal access
point p(2.0, 3.0); // p has coordinates (2.0, 3.0) point q; // q has coordinates but it is not known which
edge e;
forall(e, G.all_edges()) // dangerous!
{ ... }
// do it like this
list<edge> E = G.all_edges();
forall(e, E)
{ ... }
list_item it;
forall(it, L) {
L.append(1); // illegal; results in infinite loop
if(L[it] == 5 ) L.del(it); // legal
if(L[it] == 6 ) L.del(L.succ(it)); // illegal
L[it]++; // legal
}
class pair {
public:
int x, y;
pair() { x = y = 0; }
pair(const pair& p) { x = p.x; y = p.y; }
pair& operator=(const pair& p) {
if(this != &p) { x = p.x; y = p.y; }
return *this;
}
};
std::istream& operator>> (std::istream& is, pair& p)
{ is >> p.x >> p.y; return is; }
std::ostream& operator<< (std::ostream& os, const pair& p)
{ os << p.x << " " << p.y; return os; }
namespace leda {
int compare(const pair& p, const pair& q)
{
if (p.x < q.x) return -1;
if (p.x > q.x) return 1;
if (p.y < q.y) return -1;
if (p.y > q.y) return 1;
return 0;
}
};
namespace leda {
int Hash(const pair& p)
{
return p.x ^ p.y;
}
};
bool operator == (const pair& p, const pair& q)
{
return (p.x == q.x && p.y == q.y) ? true : false;
}