分清楚 declaration 和 definition; initializ 和 assignment
在C中可以认为 initalize 和 assignment 是一样的
但是在啊C++中是完全不一样的
在C++, int a(10); 和 int a = 10; 是等价的，两者都是初始化

构造函数的参数表如果只有一个，而且是该类对象的常引用，那么这个构造函数称为拷贝构造函数或者复制构造函数
如果没有给出复制构造函数那么编译器默认生成，默认生成的拷贝构造函数会拷贝每一个成员变量
如果这个类的成员变量是其他类的对象，那么他会让那个类的拷贝构造函数来拷贝构造那个对象
所以你的类的成员变量有其他类的对象，那么这个拷贝构造函数会被递归的下去
这个拷贝实在成员级别上的拷贝，不是在字节上的拷贝。如果有其他教科书上写的是字节级别上的拷贝，那它是错的
如果有指针的话会发生指针的拷贝，结果就是两个指针指向同一块内存
同样的道理，如果是引用，那么两个引用变量引用的是同一个
如果拷贝构造函数的参数标语是引用，那么会发生拷贝构造函数的递归

private 是针对类而不是针对 对象

Person f()
{
    Person ip;
    return ip;
}
person p = f(); 
有可能发生两种情况
    1: 直接就是 person p = ip;
    2: person tmp = ip;     p = tmp;
两种情况的发生是根据编译器的情况，有些编译器优化掉它认为不必要的拷贝构造

任何对象都只能初始化一次，之后再做相似的动作就是赋值了
在写C++程序应该尽量用string类，而不是 char *
用char * 只有一个目的，我要直接访问内存了，或者要做二进制数据
如果做得是纯字符串应该用string

建议：
    1: 写一个类，就为这个类写一个拷贝构造函数
    2: 写一个default constructor
    3: 写一个 virtual 的析构函数
    4: 不要依赖编译器给的函数
如果你的拷贝构造函数是 private 的，那么别人就无法拷贝构造你这个类的对象
java所有的对象都是通过指针来传递得到

learning record code:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>      // #include <string.h>
using namespace std;

static int objectCount = 0;

class HowMany{
    public:
        HowMany(){ objectCount ++; print("HowMany()"); }
        HowMany(int i) { objectCount ++; print("HowMany()"); }
        HowMany(const HowMany &h) { objectCount ++; print("HowMany()"); }
        void print(const string &msg = "")
        {
            if(msg.size() != 0)
                cout << msg << ": ";
            cout << "ObjectCount = " << objectCount << endl;
        }
        ~HowMany(){ objectCount --; print("~HowMany()"); }
};

HowMany f(HowMany x)
{
    cout << "begin of f" << endl;
    x.print("x argument of f()");
    cout << "end of f" << endl;
    return x;
}

class Person{
    private:
        char *name;
    public:
        Person(const char *s)
        {
            name = new char[::strlen(s) + 1];
            ::strcpy(name, s);
        }
        ~Person() { delete []name; }
        Person(const Person  & per)
        {
            name = new char[::strlen(per.name) + 1];
            ::strcpy(name, per.name);
        }
        void print();
};
void Person::print()
{
    printf("name = %p\n", name);
}

class A{
    public:
       A() { cout << "constructor called" << endl; }
       ~A() { cout << "destructor called" << endl; }
       A(const A & a) { cout << "copy constructor called" << endl; }
};

A f()
{
    A b;
    return b;
}

int main()
{
    // HowMany h;
    // h.print("afte construction of h");
    // HowMany h2 = f(h);
    // h.print("afte call to f");

    // Person p1("zhang");
    // Person p2(p1);
    // p1.print();
    // p2.print();

    A p = f();


    return 0;
}