C++ 指针和const的讨论

 

该博客主要关于指针的相关信息，包含普通指针和共享指针以及const的讨论

#include <iostream>
#include <memory>

using namespace std;

// 对于普通类型指针
#define PTR(X)       X*                // 普通指针
#define CONST_PTR(X) const X*          // 指针内容不可修改
#define PTR_CONST(X) X* const          //  指针不可修改
#define CONST_PTR_CONST(X) const X* const // 指针和指针内容不可修改

// Ptr: 普通共享指针
// ConstPtr: 不可修改内容的共享指针
// PtrConst: 不可修改指针的共享指针，内容可以修改
// ConstPtrConst: 只能初始化的指针，不能做任何的修改动作
#define SHARED_PTR_DEFINE(X) \
    public: \
    typedef std::shared_ptr<X> Ptr;  \
    typedef std::shared_ptr<const X> ConstPtr;  \
    typedef const std::shared_ptr<X> PtrConst; \
    typedef const std::shared_ptr<const X> ConstPtrConst;

class testA
{
    SHARED_PTR_DEFINE(testA)
    public:
        testA()
    {
        a = 10000;
    }

public:
    void print() const
    {
        std::cout << "a = " << a << std::endl;
    }

public:
    int a;
};

#if 0
void print(PTR(testA) p)
{
    p->print();

    p->a = 10;

    p = new testA;

    p->print();
}

void print(CONST_PTR(testA) p)
{
    p->print();

    //    p->a = 10;  // error
}

// error print(PTR(testA) p) 重定义
//void print(PTR_CONST(testA) p)
//{
//    p->print();

//    p->a = 10;

//    p = new testA(); // error
//}

// error print(CONST_PTR(testA) p) 重定义
// void print(CONST_PTR_CONST(testA) p)
// {
//    p->print();
// }

#endif

#if 1
void print(testA::Ptr p)
{
    std::cout << "B: p = " << p.use_count()
              << ", p address = " << (unsigned long long int)(&p)
              << ", p pointer address = " << (unsigned long long int)(p.get()) << std::endl;

    std::cout << "run here 3" << std::endl;
    p->print();

    p->a = 100;

     p->print();

    p.reset(new testA);

    p->print();

    std::cout << "C: p = " << p.use_count()
              << ", p address = " << (unsigned long long int)(&p)
              << ", p pointer address = " << (unsigned long long int)(p.get()) << std::endl;
}

// 共享指针对象是传值，但是，对于指针的修改同样有效
void print(testA::ConstPtr p)
{
    std::cout << "run here 2" << std::endl;
    p->print();

    // p->a = 1; // error

    p.reset(new testA);

    p->print();
}

// error: print(test::Ptr p) 重定义
//void print(testA::PtrConst p)
//{
//    p->print();

//    p->a = 1;

    p.reset(new testA);// error

//    p->print();
//}

//error: print(testA::ConstPtr p) 重定义
//void print(testA::ConstPtrConst p)
//{
//    p->print();

    p->a = 1; // error

    p.reset(new testA); // error
//}

#else
// 共享指针传地址
void print(testA::Ptr& p)
{
    std::cout << "B: p = " << p.use_count()
              << ", p address = " << (unsigned long long int)(&p)
              << ", p pointer address = " << (unsigned long long int)(p.get()) << std::endl;

    std::cout << "run here 3" << std::endl;
    p->print();

    p->a = 1;

    p.reset(new testA);

    p->print();

    std::cout << "C: p = " << p.use_count()
              << ", p address = " << (unsigned long long int)(&p)
              << ", p pointer address = " << (unsigned long long int)(p.get()) << std::endl;
}

void print(testA::ConstPtr& p)
{
    std::cout << "run here 4" << std::endl;
    p->print();

    // p->a = 1; // error

    p.reset(new testA);

    p->print();
}

void print(testA::PtrConst& p)
{
    std::cout << "run here 5" << std::endl;
    p->print();

    p->a = 1;

    //    p.reset(new testA);// error

    p->print();
}

void print(testA::ConstPtrConst& p)
{
    std::cout << "run here 6" << std::endl;
    p->print();

    //    p->a = 1; // error

    //    p.reset(new testA); // error
}
#endif

int main()
{
#if 0
    PTR(testA) p00 = new testA();

    PTR(testA) p0 = new testA();

    p0->print();

    p0 = new testA();

    p0 = p00;

    // 指针内容不可修改

    CONST_PTR(testA) p = new testA(); // p的内容是const
    p->print();

    //    p->a = 2;  // error, 不允许修改指针所指内容

    // 指针不可修改
    PTR_CONST(testA) p1 = new testA(); // p1是const

    p1->a  = 1;

    p1->print();

    //    p = p1; // error， 不允许修改指针

    // 指针和指针内容不可修改
    CONST_PTR_CONST(testA) p2 = new testA();

    p2->print();

    //    p2->a = 1; // error

    //    p2 = p1; // error



#else
    testA::Ptr p(new testA());

    p->a = 2;

    p->print();

    testA::Ptr p1(new testA());

    p = p1;

    p->print();

    // 内容不可以修改的指针
    testA::ConstPtr p2(new testA());

    p2->print();

    //    p2->a = 3; // error，指针所指的内容不可以修改

    p2.reset(new testA());  // 允许修改指针

    p2->print();

    // 指针不可以修改的指针
    testA::PtrConst p3(new testA());

    p3->a = 4;  //

    //    p3.reset(new testA()); // error 不允许修改指针

    // 只能初始化的指针
    testA::ConstPtrConst p4(new testA());

    p4->print();

    //    p4.reset(new testA()); // error 不允许修改指针

    //    p4->a = 5;    // error 不允许修改指针所指的内容

    // 共享指针对象传地址也能够将修改的指针信息返回: 用于验证引用
    std::cout << "A p = " << p.use_count()
              << ", p address = " << (unsigned long long int)(&p)
              << ", p pointer address = " << (unsigned long long int)(p.get()) << std::endl;
    print(p);

    std::cout << "D p = " << p.use_count()
              << ", p address = " << (unsigned long long int)(&p)
              << ", p pointer address = " << (unsigned long long int)(p.get()) << std::endl;
#endif
    return 0;
}