1 #include <iostream>
 2 #include <string>
 3
 4
 5 class CopyClass
 6 {
 7 public:
 8     std::string str_;
 9 public:
10     CopyClass(const std::string &str = std::string())
11             : str_(str)
12     {
13         std::cout << str_ << " constuctor CopyClass" << std::endl;
14     }
15
16     CopyClass(const CopyClass &rhs)
17             : str_(rhs.str_)
18     {
19         std::cout << str_ << " copy constructor CopyClass" << std::endl;
20     }
21
22 };
23
24 int main(int argc, char *argv[])
25 {
26     CopyClass A("A");               //explicit constructor
27     CopyClass U{"D"};               //explicit constructor
28
29     CopyClass E = CopyClass("D");     //explictt constructor
30     CopyClass B(A);                   //explicit copy constructor
31     CopyClass C = B;                  //imolicit copy constructor
32     CopyClass F = {"X"};              //implicit constructor
33     CopyClass D = {C};                //implicit copy constructor
34
35     return 0;
36 }

 1 //类值行为
 2 class HasPtr
 3 {
 4 private:
 5     int value;
 6     std::string *str;
 7 public:
 8     HasPtr(const std::string &str_ = std::string(), const int &value_ = int())
 9             : str(new std::string(str_)),
10               value(value_)
11     {
12
13         //构造对象,先构造完对象在执行构造函数体,所以函数体内一般属于赋值而不是初始化,并根据
14         //声明顺序初始化而不是形参或列表初始化顺序;
15
16     }
17
18     ~HasPtr()
19     {
20         //动态内存对象需自己手动delete释放(智能指针除外)
21         delete str;
22         //析构对象,先执行析构函数体后执行析构成员部分(隐式的,分离的)；
23         //析构成员按照声明顺序的逆序析构,内置类型无析构函数,类对象执行析构函数
24     }
25
26     //拷贝构造(以值方式传递,副本与原版互不影响)
27     HasPtr(const HasPtr &other)
28             : str(new std::string(*(other.str))),
29               value(other.value)
30     {
31
32     }
33
34     HasPtr &operator=(const HasPtr &other)
35     {
36         std::string *ptr = new std::string(*(other.str));
37         delete str;
38         str = ptr;
39         value = other.value;
40
41         return *this;
42     }
43 };

//类指针行为(共享指针)
class HasPtr_
{friend void swap(HasPtr_ &lhs, HasPtr_ &rhs);friend bool operator<(const HasPtr_ &lhs, const HasPtr_ &rhs);private:int value;std::string *str;std::size_t *use;
public:HasPtr_(const std::string &str_ = std::string()): value(0),str(new std::string(str_)),use(new std::size_t(1)){}HasPtr_(const HasPtr_ &rhs): value(rhs.value),str(rhs.str),use(rhs.use){++*use;}//对象退出作用域时会判断引用计数~HasPtr_(){if (*use == 0){delete str;delete use;}//然后退出函数体执行其他成员变量析构
    }HasPtr_ &operator=(const HasPtr_ &rhs){++*(rhs.use);     //先递增右对象引用计数;if (--*use == 0)     //判断递减左对象是否是唯一拥有则释放指针
        {delete str;delete use;}//然后赋值操作value = rhs.value;str = rhs.str;use = rhs.use;return *this;}void display(){std::cout << *str << std::endl;}};

 1 void swap(HasPtr_ &lhs, HasPtr_ &rhs)
 2 {
 3     std::cout << "HasPtr swap()" << std::endl;
 4     //声明为friend,需要使用私有变量
 5     //声明使用外部swap,防止递归
 6     using std::swap;
 7     swap(lhs.str, rhs.str);
 8     swap(lhs.use, rhs.use);
 9     swap(lhs.value, rhs.value);
10
11 }
12
13 bool operator<(const HasPtr_ &lhs, const HasPtr_ &rhs)
14 {
15     return lhs.str->length() < rhs.str->length();
16 }