// 常量指针:,指针可修改,变量不可修改(只是对于p指针来说,不能通过p指针来修改其指向的变量的值,但如果有其他指针ptr同时指向此变量,则可通过ptr修改变量的值)
// 也即,变量的不可修改只是对于指针p而言,其他指针可以正常修改变量的值 参见Effective C++ —— 让自己习惯C++（一）条款03

const int *p;

int const *p;

// 指针常量:指针不可修改(指针的指向不可修改,也即不能将p重指向其他变量),变量可修改(可通过指针p修改变量的值,当然了,也肯定可以通过其他指针修改此变量的值)

int *const p;

// 指针解引用之前,一定确保已被初始化为一个确定/合适的地址

int *p;     // 分配了指针p的内存,但并没有初始化,指针所指向的数据的内存不知道

// 指向数组的指针:指向一个数组的指针

int *p = new int[];

int a[] = {, , , , };

int (*p)[] = &a;

// 指针数组:数组的元素是地址(指针)

int b1,b2,b3,b4,b5;

int *ptr[] = {&b1, &b2, &b3, &b4, &b5};

// 指向指针数组的指针

int* (*p)[] = &ptr;

// 指针函数: 函数返回类型是某一类型的指针

int *f(x，y);

// 函数指针: 指向函数的指针变量，即本质是一个指针变量

int (*f) (int x); /* 声明一个函数指针 */

　f=func; /* 将func函数的首地址赋给指针f */

// 函数指针数组:数组的每一个元素都是一个函数指针,符合函数指针数组所规定的返回值和参数标志

double (*f_attr[])(double, double);

// 指向函数指针数组的指针

double (*(*f_attr)[])(double, double);

#include <stdio.h>

int main(int argc, char *argv[])

{

    int a = ;

    int b = ;

    // 常量指针，ptr1指针的指向可以修改

    // 但对于指针ptr1，不能通过其修改所指变量a

    // 可以通过其他方式修改变量a，变量a只对于ptr1是常量

    const int* ptr1 = &a;

    ptr1 = &b;     // ok

    // *ptr1 = b;     // Error:assignment of read-only location

    a = b;     // ok

    // 指针常量，ptr2指针的指向不可修改

    // 但指针所指向的变量可以被修改

    int* const ptr2 = &a;

    // ptr2 = &b; //Error:assignment of read-only variable `ptr2'

    *ptr2 = b;    // ok

    return ;

}

/*

 ============================================================================

 Name        : mytestPC.c

 Author      : yangxt

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */

#include <stdio.h>

#include <stdlib.h>

int nValue = ;

int main(void)

{

    // 栈区向地址减小的方向增长（向下生长）

    int* ip1, * ip2, ivalue;

    char* cp1, * cp2, cvalue;

    ip1 = (int*)0x500;

    ip2 = (int*)0x518;

    printf("ip2=%d, ip1=%d, ip2 - ip1 = %d\n", ip2, ip1, ip2 - ip1);

    printf("sizeof(ip1)=%d\n", sizeof(ip1));

    ivalue = ip2 - ip1;        // int 类型指针运算以int的长度[4Bytes]为一个单位

    cp1 = (char*)0x500;

    cp2 = (char*)0x518;

    printf("cp2=%d, cp1=%d, cp2 - cp1 = %d\n", cp2, cp1, cp2 - cp1);

    printf("sizeof(cp1)=%d\n", sizeof(cp1));         // 无论什么类型的指针，对于指针本身来说，它都是占据4Bytes

    cvalue = cp2 - cp1;     // char 类型指针运算以char的长度[1Byte]为一个单位

    printf("%d, %d\n", ivalue, cvalue);

//output:

//    ip2=1304, ip1=1280, ip2 - ip1 = 6

//    sizeof(ip1)=4

//    cp2=1304, cp1=1280, cp2 - cp1 = 24

//    sizeof(cp1)=4

//    6, 24

    return EXIT_SUCCESS;

}

/*

 * stringImpl.cpp

 *

 *  Created on: 2019年11月18日

 *      Author: yangxt

 */

#include <iostream>

#include <string.h>

//已知类String的原型如下，请编写String的4个函数：

class String

{

public:

    String(const char *str = NULL);// 普通构造函数

    String(const String &other);// 拷贝构造函数

    String();     // 无参构造函数

    ~String(void);// 析构函数

    String & operator = (const String &other);// 赋值函数

private:

    // 类含有指针成员，需要进行深拷贝

    char *m_data;// 用于保存字符串

};

// 无参构造函数

String::String()

{

    // 无参构造函数，需要置m_data==NULL

    m_data = NULL;

}

// String的析构函数

String::~String(void)

{

    delete[] m_data; // 或delete m_data;

}

//普通构造函数

String::String(const char *str)

{

    if (str == NULL)

    {

        m_data = new char[];// 对空字符串自动申请存放结束标志'\0'的，加分点：对m_data加NULL判断

        *m_data = '\0';

    }

    else

    {

        int length = strlen(str);

        m_data = new char[length + ];// 若能加 NULL 判断则更好

        if(m_data == NULL){

            exit();

        }

        strcpy(m_data, str);

    }

}

//拷贝构造函数

String::String(const String &other)// 输入参数为const型

{

    int length = strlen(other.m_data);

    // 分配内存，进行深拷贝

    m_data = new char[length + ];// 若能加 NULL 判断则更好

    if(m_data == NULL){

        exit();

    }

    strcpy(m_data, other.m_data);

}

//赋值函数

//string类的赋值运算符 参见 Effective C++ —— 构造/析构/赋值运算（二）条款10

String & String::operator = (const String &other) // 输入参数为const型

{

    // 必须先检查 自赋值

    if (this == &other)

        return *this;

    //释放原有的内存资源

    if (m_data)

        delete[] m_data;

    // 分配内存：进行深拷贝

    int length = strlen(other.m_data);

    m_data = new char[length + ];//对m_data加NULL判断

    if(m_data == NULL){

        exit();

    }

    strcpy(m_data, other.m_data);

    return *this;//返回本对象的引用

}

include<iostream>

using namespace std;

class MyClass

{

public:

    MyClass(int i = )

    {

        cout << i;

    }

    MyClass(const MyClass &x)

    {

        cout << ;

    }

    MyClass &operator=(const MyClass &x)

    {

        cout << ;

        return *this;

    }

    ~MyClass()

    {

        cout << ;

    }

};

// 题目来源：牛客网

int main()

{

    MyClass obj1(), obj2();

//obj3还不存在，所以调用拷贝构造函数输出2[最终输出122444]

//如果obj3存在，obj3=obj，则调用复制运算符重载函数，输出3[最终输出1203444]

    MyClass obj3 = obj1;

    return ;

}

// Base Class Using DMA

class baseDMA{

    private:

        char *label;

        int rating;

    public:

        baseDMA(const char *l = "null", int r = );

        baseDMA(const baseDMA &rs);

        virtual ~baseDMA();

        baseDMA & operator=(const baseDMA & rs);

        ....

}

#include <stdio.h>

int main(int argc, char *argv[])

{

    int i = ;

    int j = ;

    i++ = ; // 非左值，不能赋值

    ++j = ;      // 返回引用，左值，可以赋值

    printf("%d, %d\n", i, j);

    return ;

}

// STL 容器 deque 关于"++"运算符的实现如下：

// 前置式，如 "++i"，返回引用, 左值，可以赋值

T& operator++()

{

    ++cur;

    if (cur == last)

    {

        // to do

    }

    return *this;

}

// 后置式，如"i++"，带参，产生临时对象，性能上不如"++i"

// 非左值，不能赋值

T operator++(int)

{

    T tmp = *this;

    ++*this;

    return tmp;

}

#include <string>

int a=;    //全局初始化区

char *p1;   //全局未初始化区

void main()

{

    int b;//栈

    char s[]="abc";   //栈

    char *p2;         //栈

    char *p3="";   //123456\0在常量区，p3在栈上。

    static int c=;   //全局（静态）初始化区

    p1 = (char*)malloc();

    p2 = (char*)malloc();   //分配得来的10和20字节的区域就在堆区。

    strcpy(p1,"");   //123456\0放在常量区，编译器可能会将它与p3所向"123456\0"优化成一个地方。

}

class Test

{

public:

    Test():data() { }

private:

    int data;

};

typedef union _test

{

    Test test;

}UI;   

编译通不过，为什么呢？
     因为联合里不允许存放带有构造函数、析够函数、复制拷贝操作符等的类，因为他们共享内存，编译器无法保证这些对象不被破坏，也无法保证离开时调用析够函数。
3、又是匿名惹的祸？？ 我们先看下一段代码：

class test

{

public:

    test(const char* p);

    test(int in);

    const operator char*() const {return data.ch;}

    operator long() const {return data.l;}

private:

    enum type {Int, String };

    union

    {

        const char* ch;

        int i;

    }datatype;

    type stype;

    test(test&);

    test& operator=(const test&);

};

test::test(const char *p):stype(String),datatype.ch(p){}

test::test(int in):stype(Int),datatype.l(i){}

代码段编译通不过, 让我们来看看构造test对象时发生了什么，当创建test对象时，自然要调用其相应的构造函数，在构造函数中当然要调用其成员的构造函数，所以其要去调用datatype成员的构造函数，但是他没有构造函数可调用，所以出错。
注意了，这里可并不是匿名联合！因为它后面紧跟了个data! 
4、如何有效的防止访问出错？
使用联合可以节省内存空间，但是也有一定的风险：通过一个不适当的数据成员获取当前对象的值！为了防止这样的错误，我们必须定义一个额外的对象，来跟踪当前被存储在联合中的值得类型，我们称这个额外的对象为：union的判别式。一个比较好的经验是，在处理作为类成员的union对象时，为所有union数据类型提供一组访问函数。

int a ;

const int &ra=a;

ra=1; //错误

a=1; //正确

string foo( );

void bar(string & s);

bar(foo( ));

bar("hello world");

＃i nclude <iostream.h>

int &put(int n);

int vals[10];

int error=-1;

void main()

{

put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10;

put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20;

cout<<vals[0];

cout<<vals[9];

}

int &put(int n)

{

if (n>=0 && n<=9 ) return vals[n];

else { cout<<"subscript error"; return error; }

}

Class A; Class B : Class A{...}; B b; A& ref = b;

#include<iostream>

// （1）对象不包含虚函数表，只有虚指针，类才包含虚函数表，派生类会生成一个兼容基类的虚函数表；

// （2）virtual table 虚函数表 存放在 全局变量区；

// （3）子类多重继承自多个均带有虚函数的基类，那么子类会生成多个分别兼容各个基类的虚函数表，并且子类对象保有多个虚指针。

// （4）虚指针存在于对象实例地址的最前面，保证虚函数表有最高的性能，这个虚指针指向虚函数表；

// （5）任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法；

// （6）虚析构函数使得在删除指向子类对象的基类指针时可以调用子类的析构函数达到释放子类中堆内存的目的，而防止内存泄露的；

class A //class's size is 1

{

};

class B //4字节对齐，class's size is 8

{

private:

    int a;

    char aa;

    short bb;

};

class B1 //class's size is 1

{

private:

    void fun(){}

};

class C     //class's size is 4

{

    virtual void fun() = ;

    virtual ~C(){};

};

class D     //class's size is 4

{

public:

    // 下面3个虚函数  fun/fun1/~D 在虚函数表中将按其在类中声明的顺序排列，虚析构函数也不例外

    virtual void fun(){ std::cout << "this is a D-fun()." << std::endl;}

    virtual void fun1(){ std::cout << "this is a D-fun1()." << std::endl; }

    virtual ~D(){ std::cout << "this is a ~D()." << std::endl; };

};

class D0 : public D     //class's size is 4

{

public:

    void fun(){ std::cout << "this is a D0-fun()." << std::endl; }

    void fun1(){ std::cout << "this is a D0-fun1()." << std::endl; }

    ~D0(){ std::cout << "this is a ~D0()." << std::endl; };

};

class D1    //class's size is 4

{

    virtual void fun(){ std::cout << "this is a D2."; }

    virtual void fun1()    { std::cout << "this is a D2."; }

};

class D2 : public D1, public D     //class's size is 8

{

    virtual void fun(){ std::cout << "this is a D3."; }

    virtual void fun1() { std::cout << "this is a D3."; }

};

class D3 : public D1, public D     //class's size is 8

{

    virtual void fun3() { std::cout << "this is a D3."; }

};

class D4 : public D1, public B1     //class's size is 4

{

    virtual void fun3(){ std::cout << "this is a D3."; }

};

class E     //class's size is 1

{

    void show() { std::cout << "THIS IS E"; }

};

class F : public A    //class's size is 4

{

    virtual void show(){ std::cout << "THIS IS E"; }

};

int main()

{

    typedef void(*Fun)(void);

    Fun pFun = NULL;

    D* testD = new D0();

    // 虚指针存在于对象实例地址的最前面，保证虚函数表有最高的性能

    std::cout << "虚指针vptr地址：" << (int*)testD << std::endl;

    std::cout << "vptr指向的虚函数表地址(对vptr解引用)：" << (int*)*(int*)testD << std::endl;

    std::cout << "虚函数表 — 第一个函数地址：" << (int*)(*(int*)testD) << std::endl;

    std::cout << "虚函数表 — 第二个函数地址：" << (((int*)(*(int*)testD))+) << std::endl;

    std::cout << "虚函数表 — 第三个函数地址：" << (((int*)(*(int*)testD))+) << std::endl;

    // 多态：子类中函数覆盖了父类虚函数，在虚函数表中：覆盖的函数被放到了虚表中原来父类虚函数的位置

    testD->fun();

    pFun = (Fun)*(int*)(*(int*)testD);

    pFun();

    // 虚函数fun1 在基类D中第2个被声明，故而在虚函数表的第2元素

    testD->fun1();

    pFun = (Fun)*(((int*)(*(int*)testD))+);

    pFun();

//    "delete testD;" 既调用了子类的析构函数，又调用了父类的析构函数 -> 原理解析：

//     （1）父类的构造函数/析构函数与子类的构造函数/析构函数会形成多态，但是当父类的构造函数/析构函数即使被声明virtual，

//           子类的构造/析构方法仍无法覆盖父类的构造方法和析构方法。这是由于父类的构造函数和析构函数是子类无法继承的，也就是说每一个类都有自己独有的构造函数和析构函数。

//    （2）当delete父类的指针时，由于子类的析构函数与父类的析构函数构成多态，所以会先调用子类的析构函数；

//    （3）而delete运算符的机制又决定了: delete 父类指针所指的空间，会调用父类的析构函数。

    delete testD;

//    虚指针vptr地址：0x2fb18a0

//    vptr指向的虚函数表地址(对vptr解引用)：0x405480

//    虚函数表 — 第一个函数地址：0x405480

//    虚函数表 — 第二个函数地址：0x405484

//    虚函数表 — 第三个函数地址：0x405488

//    this is a D0-fun().

//    this is a D0-fun().

//    this is a D0-fun1().

//    this is a D0-fun1().

//    this is a ~D0().

//    this is a ~D().

    std::cout << "sizeof(A) = " << sizeof(A) << std::endl;

    std::cout << "sizeof(B) = " << sizeof(B) << std::endl;

    std::cout << "sizeof(B1) = " << sizeof(B1) << std::endl;

    std::cout << "sizeof(C) = " << sizeof(C) << std::endl;

    std::cout << "sizeof(D) = " << sizeof(D) << std::endl;

    std::cout << "sizeof(D0) = " << sizeof(D0) << std::endl;

    std::cout << "sizeof(D1) = " << sizeof(D1) << std::endl;

    std::cout << "sizeof(D2) = " << sizeof(D2) << std::endl;

    std::cout << "sizeof(D3) = " << sizeof(D3) << std::endl;

    std::cout << "sizeof(D4) = " << sizeof(D4) << std::endl;

    std::cout << "sizeof(E) = " << sizeof(E) << std::endl;

    std::cout << "sizeof(F) = " << sizeof(F) << std::endl;

    getchar();

//    sizeof(A) = 1

//    sizeof(B) = 8

//    sizeof(B1) = 1

//    sizeof(C) = 4

//    sizeof(D) = 4

//    sizeof(D0) = 4

//    sizeof(D1) = 4

//    sizeof(D2) = 8

//    sizeof(D3) = 8

//    sizeof(D4) = 4

//    sizeof(E) = 1

//    sizeof(F) = 4

}

// 深拷贝和浅拷贝  要点整理：

//（1）浅拷贝(位拷贝)只是对指针的拷贝，拷贝后两个指针指向同一个内存空间（默认拷贝构造函数），两个对象析构的时候会导致对同一个内存空间进行两次内存释放操作；

//（2）深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针（自定义拷贝构造函数）。

//总结：在对含有指针成员的对象进行拷贝时，必须要自己定义拷贝构造函数，使拷贝后的对象指针成员有自己的内存空间，即进行深拷贝，这样就避免了内存泄漏发生。

//注意：

//1、当函数的参数为对象时，实参传递给形参的实际上是实参的一个拷贝对象，系统自动通过拷贝构造函数实现；

//2、当函数的返回值为一个对象时，该对象实际上是函数内对象的一个拷贝，用于返回函数调用处。

//扩展：

//1、浅拷贝带来问题的本质在于析构函数释放多次堆内存，使用std::shared_ptr，可以完美解决这个问题；

//2、在string类的实现中，就包含了在拷贝构造函数中对于深拷贝操作的处理；

#include <iostream>

#include <string.h>

using namespace std;

class Student

{

private:

    int num;

    //类中有指针成员，需要注意对象拷贝时的深拷贝

    char *name;

public:

    Student();

    ~Student();

    Student(const Student &s);//拷贝构造函数，const防止对象被改变

};

Student::Student()

{

    name = new char();

    cout << "Student" << endl;

}

Student::~Student()

{

    cout << "~Student " << (int)name << endl;

    delete name;

    name = NULL;

}

// 浅拷贝：没有自定义拷贝构造函数的情况下，会调用默认拷贝构造函数进行浅拷贝(只会复制类指针成员的值，不会复制指针所指向的内容)

// 深拷贝：自定义拷贝构造函数实现深拷贝(复制类指针成员所指向的内容)；

// test：可以尝试把自定义拷贝构造函数屏蔽，看看程序执行结果(验证释放同一内存空间两次会导致什么结果)

Student::Student(const Student &s)

{

    name = new char();

    memcpy(name, s.name, strlen(s.name));

    cout << "copy Student" << endl;

}

int main()

{

    {// 花括号让s1和s2变成局部对象，方便测试

        Student s1;

        // 复制对象，如果有自定义拷贝构造函数则调用自定义拷贝构造函数，否则调用默认拷贝构造函数

        Student s2(s1);

    }

    system("pause");

    return ;

}

//output:

//Student

//copy Student

//~Student 1120432

//~Student 1120416

#include <memory>

#include <iostream>

#include <string>

#include <vector>

// C++98 & C++11

class Simple {

public:

    Simple(int param = )

    {

        number = param;

        std::cout << "Simple: " << number << std::endl;

    }

    ~Simple()

    {

        std::cout << "~Simple: " << number << std::endl;

    }

    void PrintSomething()

    {

        std::cout << "PrintSomething: " << info_extend.c_str() << std::endl;

    }

    std::string info_extend;

    int number;

};

void TestAutoPtrC98()

{

    // C++11 不建议再使用std::auto_ptr -> 'template<class> class std::auto_ptr' is deprecated [-Wdeprecated-declarations]

    std::auto_ptr<Simple> my_memory(new Simple());   // 创建对象，输出：Simple：1

    if (my_memory.get()) {                            // 判断智能指针是否为空

        my_memory->PrintSomething();                    // 使用 operator-> 调用智能指针对象中的函数

//        my_memory.get()->info_extend = "Addition";      // 使用 get() 返回裸指针，然后给内部对象赋值

        my_memory->info_extend = "Addition";             // 和“my_memory.get()->info_extend = "Addition";”等价

        my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功

        (*my_memory).info_extend += " other";           // 使用 operator* 返回智能指针内部对象，然后用“.”调用智能指针对象中的函数

        my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功

    }

//    output:

//    Simple: 1

//    PrintSomething:

//    PrintSomething: Addition

//    PrintSomething: Addition other

//    ~Simple: 1

}

// C++11 提供了 std::shared_ptr(共享) 和 std::unique_ptr(独占)，并不建议再使用std::auto_ptr智能指针

int TestSharedPtrC11(void)

{

    // two shared pointers representing two persons by their name

    std::shared_ptr<std::string> pNico(new std::string("nico"));

    std::shared_ptr<std::string> pJutta(new std::string("jutta"),

            // deleter (a lambda function)

            [](std::string *p)

            {

                std::cout << "delete " << *p << std::endl;

                delete p;

            }

        );

    // capitalize person names

    (*pNico)[] = 'N';

    pJutta->replace(, , "J");

    // put them multiple times in a container

    std::vector<std::shared_ptr<std::string>> whoMadeCoffee;

    whoMadeCoffee.push_back(pJutta);

    whoMadeCoffee.push_back(pJutta);

    whoMadeCoffee.push_back(pNico);

    whoMadeCoffee.push_back(pJutta);

    whoMadeCoffee.push_back(pNico);

    // print all elements

    for (auto ptr : whoMadeCoffee)

        std::cout << *ptr << " ";

    std::cout << std::endl;

    // overwrite a name again

    *pNico = "Nicolai";

    // print all elements

    for (auto ptr : whoMadeCoffee)

        std::cout << *ptr << " ";

    std::cout << std::endl;

    // print some internal data

    std::cout << "use_count: " << whoMadeCoffee[].use_count() << std::endl;

    // 默认内存释放器并不能释放数组内存空间，而是要我们自己提供内存释放器

    std::shared_ptr<int> pYangxt(new int[],

            // deleter (a lambda function)

            [](int *p)

            {

                std::cout << "pYangxt=0 -> delete[] p " << std::endl;

                delete[] p;

            }

        );

    // 后定义的指针，函数退出的时候会先被释放（局部变量存放在栈中，先进后出）

    std::shared_ptr<int> pYangxt1(new int(),

            // deleter (a lambda function)

            [](int *p)

            {

                std::cout << "pYangxt=1 -> delete p " << std::endl;

                delete p;

            }

        );

    return ;

//output:

//    Jutta Jutta Nico Jutta Nico

//    Jutta Jutta Nicolai Jutta Nicolai

//    use_count: 4

//    pYangxt=1 -> delete p

//    pYangxt=0 -> delete[] p

//    delete Jutta

//    关于程序的几点说明：

//    　　1）对智能指针pNico的拷贝是浅拷贝，所以当我们改变对象“Nico”的值为“Nicolai”时，指向它的指针都会指向新值；

//    　　2）指向对象“Jutta”的有四个指针：pJutta和pJutta的三份被安插到容器内的拷贝，所以上述程序输出的use_count为4；

//    　　3）shared_ptr本身提供默认内存释放器（default deleter），调用的是delete，不过只对“由new建立起来的单一对象”起作用。当然我们也可以自己定义内存释放器，就如上述程序

}

#include <iostream>

using namespace std;

// 简单实现 基于引用计数的智能指针(shared_ptr)，一般都定义成模板类，以支持各种类型指针的管理

// 所有的智能指针都会重载 -> 和 * 操作符，本示例中我们并没有重载，只是简单实现 拷贝/赋值 功能。

// 智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。

template<class T>

class SmartPtr

{

public:

    SmartPtr(T *p);

    ~SmartPtr();

    // 浅拷贝：shared_ptr(共享对象)只有一个对象，其他指针都指向该对象

    SmartPtr(const SmartPtr<T> &orig);

    SmartPtr<T>& operator=(const SmartPtr<T> &rhs);    // 浅拷贝

    int get_use_count();

private:

    T *ptr;

    // 将use_count声明成指针是为了方便对其进行递增或递减操作

    int *use_count;

};

template<class T>

int SmartPtr<T>::get_use_count()

{

    return *use_count;

}

// 采用初始化列表的方式初始化智能指针的ptr成员

template<class T>

SmartPtr<T>::SmartPtr(T *p) : ptr(p)

{

    try

    {

        use_count = new int();

    }

    catch (...)

    {

        // 捕获new运算符 分配内存空间失败的异常

        delete ptr;

        ptr = nullptr;

        use_count = nullptr;

        cout << "Allocate memory for use_count fails." << endl;

        exit();

    }

    cout << "Constructor is called!" << endl;

}

template<class T>

SmartPtr<T>::~SmartPtr()

{

    // 只在最后一个对象引用ptr时才释放内存

    if (--(*use_count) == )

    {

        delete ptr;

        delete use_count;

        ptr = nullptr;

        use_count = nullptr;

        cout << "Destructor is called!" << endl;

    }

}

// 浅拷贝：shared_ptr(共享对象)只有一个对象，其他指针都指向该对象

template<class T>

SmartPtr<T>::SmartPtr(const SmartPtr<T> &orig)

{

    ptr = orig.ptr;

    use_count = orig.use_count;

    ++(*use_count);

    cout << "Copy constructor is called!" << endl;

}

// 重载等号函数不同于复制构造函数，即等号左边的对象可能已经指向某块内存。

// 这样，我们就得先判断左边对象指向的内存已经被引用的次数。如果次数为1，

// 表明我们可以释放这块内存；反之则不释放，由其他对象来释放。

template<class T>

SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr<T> &rhs)

{

    // 《C++ primer》：“这个赋值操作符在减少左操作数的使用计数之前使rhs的使用计数加1，

    // 从而防止自身赋值”而导致的提早释放内存

    ++(*rhs.use_count);

    // 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象

    if (--(*use_count) == )

    {

        delete ptr;

        delete use_count;

        cout << "Left side object is deleted!" << endl;

    }

    ptr = rhs.ptr;

    use_count = rhs.use_count;

    cout << "Assignment operator overloaded is called!" << endl;

    return *this;

}

// 实现简单智能指针

int TestMySmartPtr()

{

    // Test Constructor and Assignment Operator Overloaded

    SmartPtr<int> p1(new int());

    cout << "p1.use_count = " << p1.get_use_count() << endl;

    // Test Copy Constructor

    SmartPtr<int> p2(p1);

    cout << "p1.use_count = " << p1.get_use_count() << endl;

    cout << "p2.use_count = " << p2.get_use_count() << endl;

    // Test Assignment Operator Overloaded

    SmartPtr<int> p3(new int());

    p3 = p1;

    cout << "p1.use_count = " << p1.get_use_count() << endl;

    cout << "p2.use_count = " << p2.get_use_count() << endl;

    cout << "p3.use_count = " << p3.get_use_count() << endl;

    return ;

//    output:

//    !!!Hello world!!!

//    Constructor is called!

//    p1.use_count = 1

//    Copy constructor is called!

//    p1.use_count = 2

//    p2.use_count = 2

//    Constructor is called!

//    Left side object is deleted!

//    Assignment operator overloaded is called!

//    p1.use_count = 3

//    p2.use_count = 3

//    p3.use_count = 3

//    Destructor is called!

}