C++智能指针类型转换

C++智能指针类型转换一

#include <iostream>
#include <memory>
 
struct Base 
{ 
    int a; 
    virtual void f() const { std::cout << "I am base!\n";}
    virtual ~Base(){}
};
 
struct Derived : Base
{
    void d()
    { std::cout << "Derived:d()\n"; }
    void f() const override
    { std::cout << "I am derived!\n"; }
    ~Derived(){}
};
 
int main(){
    auto basePtr = std::make_shared<Base>();
    std::cout << "Base pointer says: ";
    basePtr->f();
 
    auto derivedPtr = std::make_shared<Derived>();
    std::cout << "Derived pointer says: ";
    derivedPtr->f();
    
    
    // 上行的转换（派生类到基类的转换）
    std::cout << "Derived pointer static_pointer_cast to Base says: ";
    std::static_pointer_cast<Base>(derivedPtr)->f();


    // 直接转型，不构造临时 shared_ptr
    // 下行的转换（基类到派生类的转换)
    std::cout << "Base pointer static_cast to derived says: ";
    static_cast<Derived*>(basePtr.get())->d();

    // 构造临时 shared_ptr ，然后调用 operator->
    // 下行的转换（基类到派生类的转换)
    std::cout << "Base pointer static_pointer_cast to derived says: ";
    std::static_pointer_cast<Derived>(basePtr)->d();

    // 转换成对象
    // 下行的转换（基类到派生类的转换)
    Derived& derived = static_cast<Derived&>(*basePtr);
    std::cout << "Base pointer static_cast to derived Obeject says: ";
    derived.d();

    // std::cout << "Base pointer dynamic_cast to derived says: ";
    // dynamic_cast<Derived*>(basePtr.get())->f();  //段错误

    // Derived& derived1 = dynamic_cast<Derived&>(*basePtr);
    // derived1.d();       // 异常

    // 下行的转换（基类到派生类的转换)
    auto downcastedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
    if(downcastedPtr)
    { 
        std::cout << "Base pointer dynamic_pointer_cast to derived says: ";
        downcastedPtr->d(); 
    }
 
    // All pointers to derived share ownership
    std::cout << "Pointers to underlying derived: " 
            << derivedPtr.use_count() 
            << "\n"; 
}

C++智能指针类型转换二

#include<iostream>
#include<string>
#include<memory>
#include<unordered_map>
using namespace std;

struct Base
{
	int age;
	string name;
	Base() {}
	Base(int age,string name):age(age),name(name) {}
	virtual ~Base() {}
};
struct Derived : Base
{
	int age;
	string name;
	Derived(int age,string name):age(age),name(name) {}
	~Derived(){}
};
int func1(unordered_map<int, shared_ptr<string>> sp)
{
	for(auto pair : sp)
	{
		sp[pair.first] = make_shared<string>("null");
	}
	unordered_map<int, shared_ptr<string>>::iterator it;
	for(it = sp.begin(); it != sp.end(); ++it)
	{
		cout<<"key="<<it->first<<" value="<<*(it->second)<<endl;
	}
	return 0;
}
int func2(unordered_map<int, shared_ptr<Base>> sp)
{
	for (auto &pair : sp)
	{
		cout<<"key="<<pair.first<<" value="<<dynamic_pointer_cast<Derived>(sp[pair.first])->name<<endl;
	}
	return 0;
}
int func3(unordered_map<int, shared_ptr<Base>> &sp)
{
	for (auto &pair : sp)
	{
		shared_ptr<Derived> der = dynamic_pointer_cast<Derived>(pair.second);
		cout<<"key="<<pair.first<<" value="<<der->name<<endl;
	}
	return 0;
}
int main()
{
	unordered_map<int, shared_ptr<string>> um1;

	shared_ptr<string> pStra = make_shared<string>("tom");
	shared_ptr<string> pStrb = make_shared<string>("jerry");

	um1.insert(pair<int, shared_ptr<string>>(0,pStra));
	um1.insert(pair<int, shared_ptr<string>>(1,pStrb));

	func1(um1);


	unordered_map<int, shared_ptr<Base>> um2;

	shared_ptr<Derived> pJcea = make_shared<Derived>(2,"lisa");
	shared_ptr<Derived> pJceb = make_shared<Derived>(3,"jean");

	um2 = {{2,static_pointer_cast<Base>(pJcea)},{3,static_pointer_cast<Base>(pJceb)}};

	func2(um2);


	unordered_map<int, shared_ptr<Base>> um3;
        //这样um4,um5,um6,um7,um8都指向同一区域 对一个指针操作相当于对所有指针操作
	shared_ptr<int> um4,um5,um6,um7,um8 = make_shared<int>();
        //改成下面这样就能使每一个指针指向不同区域
	// shared_ptr<int> um4 = make_shared<int>();
	// shared_ptr<int> um5 = make_shared<int>();
	// shared_ptr<int> um6 = make_shared<int>();
	// shared_ptr<int> um7 = make_shared<int>();
	// shared_ptr<int> um8 = make_shared<int>();

	shared_ptr<Derived> pJcec = make_shared<Derived>(4,"bob");
	shared_ptr<Derived> pJced = make_shared<Derived>(5,"luby");

	um3 = {{4,static_pointer_cast<Base>(pJcec)},{5,static_pointer_cast<Base>(make_shared<Derived>(6,"luby"))}};

	func3(um3); // shared_ptr<JceStructBase>
	return 0;
}

解释1

这里是定义了两个指针pStra pStrb，指向不同区域 并初始化不同的值，然后调用func1()输出内容

	unordered_map<int, shared_ptr<string>> um1;

	shared_ptr<string> pStra = make_shared<string>("tom");
	shared_ptr<string> pStrb = make_shared<string>("jerry");

	um1.insert(pair<int, shared_ptr<string>>(0,pStra));
	um1.insert(pair<int, shared_ptr<string>>(1,pStrb));

	func1(um1);

运行结果:

解释2

这里是定义了两个指针pJcea pJceb，指向不同区域，并初始化值，在往um2里面插入数据时，使用静态转换，把子类转为父类，类似多态概念，然后调用func2()输出

	unordered_map<int, shared_ptr<Base>> um2;

	shared_ptr<Derived> pJcea = make_shared<Derived>(2,"lisa");
	shared_ptr<Derived> pJceb = make_shared<Derived>(3,"jean");

	um2 = {{2,static_pointer_cast<Base>(pJcea)},{3,static_pointer_cast<Base>(pJceb)}};

	func2(um2);

运行结果:

解释3

对于这样的定义，是指所有的指针都指向同一区域 对一个指针操作相当于对所有指针操作，对于其他指针指向也全部都改变了，刚刚踩过的坑，gdb了好久

	shared_ptr<int> um4,um5,um6,um7,um8 = make_shared<int>();

解释4

对于这样的定义，是指所有的指针都指向不同区域 对一个指针操作不影响其他指针

	shared_ptr<int> um4 = make_shared<int>();
	shared_ptr<int> um5 = make_shared<int>();
	shared_ptr<int> um6 = make_shared<int>();
	shared_ptr<int> um7 = make_shared<int>();
	shared_ptr<int> um8 = make_shared<int>();

解释5

定义了两个变量pJcec pJced 并初始化值，调用时又初始化了一个值static_pointer_cast(make_shared(6,"luby"))，临时值

        unordered_map<int, shared_ptr<Base>> um3;
	shared_ptr<Derived> pJcec = make_shared<Derived>(4,"bob");
	shared_ptr<Derived> pJced = make_shared<Derived>(5,"luby");

	um3 = {{4,static_pointer_cast<Base>(pJcec)},{5,static_pointer_cast<Base>(make_shared<Derived>(6,"luby"))}};

	func3(um3); // shared_ptr<JceStructBase>

运行结果: