1. for循环是开界的。它的一般形式为: for(<初始化>; <条件表达式>; <增量>) 语句; 初始化总是一个赋值语句, 它用来给循环控制变量赋初值; 条件表达式是一个关系表达式, 它决定什么时候退出循环; 增量定义循环控制变量每循环一次后 按什么方式变化。这三个部分之间用";"分开。 例如: for(i=1; i<=10; i++) 语句; 上例中先给 " i " 赋初值1, 判断 " i " 是否小于等于10, 若是则执行语句, 之后值增 加1。再重新判断, 直到条件为假, 即i>10时, 结束循环。
for循环中，初始化的语句只执行一次，后面的条件判断是每次都判断的，然后进行增量操作，增量操作仅在第二次循环开始时执行。
2. 拷贝构造函数
拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。其唯一的参数（对象的引用）是不可变的（const类型）。
在C++中，下面三种对象需要调用拷贝构造函数（有时也称“复制构造函数”）：
1) 一个对象作为函数参数，以值传递的方式传入函数体； 2) 一个对象作为函数返回值，以值传递的方式从函数返回； 3) 一个对象用于给另外一个对象进行初始化（常称为复制初始化）；如果在前两种情况不使用拷贝构造函数的时候，就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是拷贝构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作符共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。
3. 赋值函数
每个类只有一个赋值函数.
由于并非所有的对象都会使用 拷贝构造函数 和赋值函数，程序员可能对这两个函数有些轻视。请先记住以下的警告，在阅读正文时就会多心： 1. 如果不主动编写拷贝构造函数和赋值函数， 编译器 将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有 指针变量 ，那么这两个缺省的函数就隐含了错误。以类String的两个对象a,b为例，假设a.m_data的内容为“hello”，b.m_data的内容为“world”。 现将a赋给b，缺省赋值函数的“位拷贝”意味着执行b.m_data = a.m_data。这将造成三个错误：一是b.m_data原有的内存没被释放，造成内存泄露；二是b.m_data和a.m_data指向同一块内存，a或b任何一方变动都会影响另一方；三是在对象被析构时，m_data被释放了两次。 2. 拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。以下程序中，第三个语句和第四个语句很相似，你分得清楚哪个调用了拷贝构造函数，哪个调用了赋值函数吗？注意：一个是在对象的拷贝到时候调用的，也就是在对象创建的情况下使用。另外一个是在已经有了对象的情况下，对对象进行赋值作用。在编程的时候，要考虑到拷贝和赋值函数的编写，防止出现内存管理错误。
String a(“hello”);
String b(“world”); String c = a; // 调用了拷贝构造函数，最好写成 c(a);，这一句的风格较差，宜改写成String c(a) 以区别于下面的句子 c = b; // 调用了赋值函数
拷贝函数和赋值函数应该如下：
String::String(const String &other)
{ // 允许操作other的私有成员m_data int length = strlen(other.m_data); m_data = new char[length+1]; strcpy(m_data, other.m_data); } // 赋值函数 String & String::operator =(const String &other) { // (1) 检查自赋值 if(this == &other) return *this;}
4. 关于函数的构造函数
对于一个类的默认构造函数，其声明函数是： Test b；而不是Test b()；否则会造成之后的程序错误。
5. 静态成员变量：为所有的类实例之间共享，一旦改变则所有地方的值都改变。请注意static类成员永远也不会在类的构造函数初始化。静态成员在程序运行的过程中只被初始化一次，所以每当类的对象创建时都去“初始化”它们没有任何意义。至少这会影响效率：既然是“初始化”，那为什么要去做多次？而且，静态类成员的初始化和非静态类成员有很大的不同
6. 类对象的初始化，在构造函数的后面加上冒号：
尽量使用初始化而不要在构造函数里赋值
看这样一个模板，它生成的类使得一个名字和一个t类型的对象的指针关联起来。
template <class t>
class namedptr {
public:
namedptr(const string& initname, t *initptr);
...
private:
string name;
t *ptr;
};
（因为有指针成员的对象在进行拷贝和赋值操作时可能会引起指针混乱（见条款11），namedptr也必须实现这些函数（见条款2））
在写namedptr构造函数时，必须将参数值传给相应的数据成员。有两种方法来实现。第一种方法是使用成员初始化列表：
template <class t>
namedptr <t> ::namedptr(const string& initname, t *initptr )
: name(initname), ptr(initptr)
{}
第二种方法是在构造函数体内赋值：
template <class t>
namedptr <t> ::namedptr(const string& initname, t *initptr)
{
name = initname;
ptr = initptr;
}
两种方法有重大的不同。
从纯实际应用的角度来看，有些情况下必须用初始化。特别是const和引用数据成员只能用初始化，不能被赋值。所以，如果想让namedptr <t> 对象不能改变它的名字或指针成员，就必须遵循条款21的建议声明成员为const：
template <class t>
class namedptr {
public:
namedptr(const string& initname, t *initptr);
...
private:
const string name;
t * const ptr;
};
这个类的定义要求使用一个成员初始化列表，因为const成员只能被初始化，不能被赋值。
如果namedptr <t> 对象包含一个现有名字的引用，情况会非常不同。但还是要在构造函数的初始化列表里对引用进行初始化。还可以对名字同时声明const和引用，这样就生成了一个其名字成员在类外可以被修改而在内部是只读的对象。
template <class t>
class namedptr {
public:
namedptr(const string& initname, t *initptr);
...
private:
const string& name; // 必须通过成员初始化列表
// 进行初始化
t * const ptr; // 必须通过成员初始化列表
// 进行初始化
};
然而前面最初的类模板不包含const和引用成员。即使这样，用成员初始化列表还是比在构造函数里赋值要好。这次的原因在于效率。当使用成员初始化列表时，只有一个string成员函数被调用。而在构造函数里赋值时，将有两个被调用。为了理解为什么，请看在声明namedptr <t> 对象时都发生了些什么。
对象的创建分两步：
1. 数据成员初始化。（参见条款13）关于初始化的顺序问题，是跟变量声明的顺序一致的，而不是初始化列表顺序决定的。
2. 执行被调用构造函数体内的动作。
（对有基类的对象来说，基类的成员初始化和构造函数体的执行发生在派生类的成员初始化和构造函数体的执行之前）
对namedptr类来说，这意味着string对象name的构造函数总是在程序执行到namedptr的构造函数体之前就已经被调用了。问题只在于：string的哪个构造函数会被调用？
这取决于namedptr类的成员初始化列表。如果没有为name指定初始化参数，string的缺省构造函数会被调用。当在namedptr的构造函数里对name执行赋值时，会对name调用operator=函数。这样总共有两次对string的成员函数的调用：一次是缺省构造函数，另一次是赋值。
相反，如果用一个成员初始化列表来指定name必须用initname来初始化，name就会通过拷贝构造函数以仅一个函数调用的代价被初始化。
即使是一个很简单的string类型，不必要的函数调用也会造成很高的代价。随着类越来越大，越来越复杂，它们的构造函数也越来越大而复杂，那么对象创建的代价也越来越高。养成尽可能使用成员初始化列表的习惯，不但可以满足const和引用成员初始化的要求，还可以大大减少低效地初始化数据成员的机会。
换句话说，通过成员初始化列表来进行初始化总是合法的，效率也决不低于在构造函数体内赋值，它只会更高效。另外，它简化了对类的维护（见条款m32），因为如果一个数据成员以后被修改成了必须使用成员初始化列表的某种数据类型，那么，什么也不用变。
但有一种情况下，对类的数据成员用赋值比用初始化更合理。这就是当有大量的固定类型的数据成员要在每个构造函数里以相同的方式初始化的时候。例如，这里有个类可以用来说明这种情形：
class manydatambrs {
public:
// 缺省构造函数
manydatambrs();
// 拷贝构造函数
manydatambrs(const manydatambrs& x);
private:
int a, b, c, d, e, f, g, h;
double i, j, k, l, m;
};
假如想把所有的int初始化为1而所有的double初始化为0，那么用成员初始化列表就要这样写：
manydatambrs::manydatambrs()
: a(1), b(1), c(1), d(1), e(1), f(1), g(1), h(1), i(0),
j(0), k(0), l(0), m(0)
{ ... }
manydatambrs::manydatambrs(const manydatambrs& x)
: a(1), b(1), c(1), d(1), e(1), f(1), g(1), h(1), i(0),
j(0), k(0), l(0), m(0)
{ ... }
这不仅仅是一项讨厌而枯燥的工作，而且从短期来说它很容易出错，从长期来说很难维护。
然而你可以利用固定数据类型的（非const, 非引用）对象其初始化和赋值没有操作上的不同的特点，安全地将成员初始化列表用一个对普通的初始化函数的调用来代替。
class manydatambrs {
public:
// 缺省构造函数
manydatambrs();
// 拷贝构造函数
manydatambrs(const manydatambrs& x);
private:
int a, b, c, d, e, f, g, h;
double i, j, k, l, m;
void init(); // 用于初始化数据成员
};
void manydatambrs::init()
{
a = b = c = d = e = f = g = h = 1;
i = j = k = l = m = 0;
}
manydatambrs::manydatambrs()
{
init();
...
}
manydatambrs::manydatambrs(const manydatambrs& x)
{
init();
...
}
因为初始化函数只是类的一个实现细节，所以当然要把它声明为private成员。
7.const 只能在构造函数的初始化列表里初始化，
- 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
- 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
- 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
- const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
- 不要轻易的将函数的返回值类型定为const;
- 除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;
- const的初始化：
对常量成员的初始化，你应该在类的构造函数的初始化部分初始化，而非像静态类成员那样在类声明中初始化。
像这样：
class abc
{
public:
abc();
private:
const int ab;
};
abc::abc():ab(0)//在这里初始化。
{}
这是因为，对于静态成员来说，它是属于所有的类对象的，在内存中只存在一份拷贝，自然对于它的初始化只能进行一次，所以初始化它的方法被设计在了类声明中，而非类对象的定义中。
而常量成员const呢，它是每个类对象都会拥有一份拷贝，所以它的初始化应该随着每个类对象的构造而进行一次，所有它的初始化只能存在于类的构造函数中。
8.
8930
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
