之前我们讨论过类成员的组成，尤其是成员函数，我们知道了定义一个类的时候，我们往往定义了：构造函数，析构函数，其他函数，以及友元函数（友元函数不是必须的）。
同时，我们知道了这样一个事情：在定义一个对象的时候：构造函数会被调用；对象被销毁的时候：会调用析构函数。友元函数提供给我们访问成员的另一种方式。
但这其中，会产生更多的细节。通过一些具体的细节，我们来感受一些类中的行为：
类声明如下：
# include "iostream"
# ifndef STRNGBAD_H_
# define STRNGBAD_H_
class StringBad
{
private:
char *str;
int len;
static int num_strings; //= 0;//可见除了const 量之外，类内部成员是不能在内部赋初值的
public:
StringBad(const char * s);
StringBad();
~StringBad(); friend std::ostream & operator<<(std::ostream & os, const StringBad & st);
};
# endif
上述这个类声明中：
和通常一样：包含了构造函数，析构函数，友元函数；但这里需要强调的是 静态成员变量：num_strings。当我们使用StringBad类生成A,B,C....诸多类对象的时候，A.str，B.str，C.str....这些变量本质上地址是不同的。但是A.num_strings，B.num_strings，A.num_strings，地址是相同的。即：静态成员是属于类，而不是属于对象的。
我们看看这个类的定义：
# include "cstring"
# include "strngbad.h" using std::cout; int StringBad::num_strings = ; StringBad::StringBad(const char*s)
{
len = std::strlen(s);
str = new char[len + ];
std::strcpy(str, s);
num_strings++;
cout << num_strings << ": \"" << str << "\" object created\n";
} StringBad::StringBad()
{
len = ;
str = new char[];
std::strcpy(str, "C++");
num_strings++;
cout << num_strings << ": \"" << str << "\" default created\n";
} StringBad::~StringBad()
{
cout << "\"" << str << "\" object created. ";
--num_strings;
cout << num_strings << "left\n";
delete[] str;
} std::ostream & operator<<(std::ostream & os, const StringBad & st)
{
os << st.str;//注意这里打印的是 str，如果不加str呢
return os;
}
关于这个类定义：我们注意这么几点：第6行进行了静态变量的初始化。注意，对num_strings 进行初始化的时候，StringBad::num_strings表明num_strings成员属于StringBad
问题：可以在类声明中进行初始化吗？
答：不可以，类声明只是说明需要为什么样的类型分配多少空间，但并不真正的分配空间，因此不能在声明中初始化（const除外）。
从这个类定义文件可以看出：无论是描述类成员函数，还是类成员变量.我们都要在前面描述其作用域！
new 和delete在动态内存分配中是十分重要的。但是要注意：在构造函数中使用了new[]，在析构函数中必有delete[].
继续看调用文件:
# include "iostream"
using std::cout;
# include "strngbad.h" void callme1(StringBad &);
void callme2(StringBad); int main()
{
using std::endl;
{
cout << "Starting an inner block.\n";
StringBad headline1("hello world!");
StringBad headline2("learning forever!");
StringBad sports("i love trvaling!");
cout << "headline1" << headline1 << endl;
cout << "headline12"<< headline2 << endl;
cout << "sports" << sports << endl;
callme1(headline1);
cout << "headline1" << headline1 << endl;
callme2(headline2);
cout << "headline2" << headline2 << endl;
cout << "Initialize one object to another:\n";
StringBad sailor = sports;
cout << "sailor: " << sailor << endl;
}
cout << "End of main()\n";
system("pause");
return ;
} void callme1(StringBad & rsb)
{
cout << "String passed by reference:\n";
cout << " \n" << rsb << "\"\n";
} void callme2(StringBad sb)
{
cout << "String passed by rvalue:\n";
cout << " \n" << sb << "\"\n";
}
在此，给出第19行代码和第21行代码的一些细节：
第19行代码，传递参数的行为是引用传递，21行为：值传递。
再次强调:值传递 和 值返回 函数的两个本质特征：1. 进行值传递的时候，复制实参的副本，使得形参为实参的副本；2. 值返回的时候，复制返回值的副本（并销毁该变量（因为栈中的变量生存周期为函数调用期）），对副本进行后续操作。
因此第21行的代码：在进行按值传递的时候，首先创建一个对象的副本。但在创建对象副本的时候，首先会调用构造函数，但是这个构造函数是谁呢？是之前类定义中的构造函数吗？如果是，显然这个创建副本的形式应该为：()或者（cha*），但问题是：这里是吗？？？显然不是，那是什么呢？？？其实为：B=A，即将已知的对象A赋值给临时对象B，这就如同第24行的代码。那么这样的初始化方式，调用哪个构造函数呢？？？其实，是一种叫做赋值构造函数，专门应对这种赋值初始化的操作。很明显，之前的声明和定义中并没有赋值构造函数。那么这个赋值构造函数只能由编译器产生。
终于知道为何开始要求我们采用()或者{}的初始化方式，而不是"="的初始化方式。因为通常的我们可能并没有显示的定义自己的赋值构造函数，这个时候由编译器产生一个这样的函数，可能会存在一定的风险。但如果我们不可避免会采用到=或者值传递创建函数的形式，我们应该显示的定义自己的赋值构造函数，使得我们的程序风险更低。（实际上，通常的定义一个显示赋值构造函数更保险）
总结：按值传递和按值返回对象的时候，都将调用赋值构造函数！2构造函数中创建一个显示赋值构造函数通常更保险
我们在此再次声明：“hello World！”表示一个地址而不是字符串。当我们定义：p = “hello Word！”，假如我们定义：q = p，那么：是否是将字符串P复制了一遍，并存到了q的地址呢？并不是，而是：p，q都指向了“hello world！”，而这个时候，“hello world! ”其实看起来更像地址。