プログラマ専用SNS ミクプラ

コード:

struct Base;//純粋仮想クラス
struct A : public Base;
struct B : public Base;

struct MyClass
{
    std::unique_ptr<Base> p;
    MyClass(const MyClass &obj)//??
    {
        this->p = std::move(obj.p);//constついてるから無理
        this->p=make_unique//objのpがAかBかわからない
        *this->p=*obj.p;//new してないから値が入らない？
    }
}

コード:

struct MyClass
{
    std::unique_ptr<Base> p_;
    explicit MyClass(std::unique_ptr<Base>&& p) : p_(std::move(p)) {}
    explicit MyClass(MyClass &&obj) { this->p_ = std::move(obj.p_); }
private:
    MyClass(const MyClass &);              // copy constructor 禁止
    MyClass &operator=(const MyClass &);   // 代入演算子禁止
};

コード:

struct MyClass
{
    struct Impl;
    std::unique_ptr<Impl> pimpl;
    MyClass();
};

struct Super;
struct SubA : public Super;
struct SubB : public Super;

struct MyClass::Impl
{
    std::unique_ptr<Super> p_obj;
    Impl();
};

int main()
{
    std::vector<MyClass> obj_list {MyClass(), MyClass()};
    std::reverse(std::begin(obj_list), std::end(obj_list) );//error　内部でoperator=が呼び出されてるっぽい
}

コード:

struct MyClass
{
    struct Impl;
    std::unique_ptr<Impl> pimpl;
    MyClass();
    MyClass& operator=(const Myclass &obj)//constの参照型じゃないとerror
    {
        this->pimpl=std::make_unique<Impl>(*obj.pimpl);//obj.pimplの内容をコピーして新たなポインタを作る
        return *this;
    }
};

struct MyClass::Impl
{
    std::unique_ptr<Super> p_obj;
    Impl();
    Impl(Impl &obj) : p_obj(std::move(obj.p_obj) ) {}//こっちはconstついてなくてもセーフ
};

コード:

#include <typeinfo>
...
    MyClass(const MyClass &obj) {
        if (typeid(*obj.p_) == typeid(A)) {
            this->p_ = make_unique<A>();
            *this->p_ = *obj.p_;
        } else if (typeid(*obj.p_) == typeid(B)) {
            this->p_ = make_unique<B>();
            *this->p_ = *obj.p_;
        } else {
            cout << "Error copy construct" << endl;
        }
    }

コード:

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <memory>
#include <algorithm>

using namespace std;

class Base
{
protected:
	int i;
public:
	Base(int i) : i(i) {}
	Base(const Base& obj) { i = obj.i; }
	virtual ~Base() { cout << "~Base() : i = " << i << endl; }

	virtual string get_status()
	{
		stringstream ss;
		ss << "i = " << i << " : " << typeid(Base).name();
		return ss.str();
	}
};

class B : public Base
{
public:
	using Base::Base;
	~B() { cout << "~B(),"; }

	string get_status() override
	{
		stringstream ss;
		ss << "i = " << i << " : " << typeid(B).name();
		return ss.str();
	}
};

class C : public Base
{
public:
	using Base::Base;
	virtual ~C() { cout << "~C(),"; }

	string get_status() override
	{
		stringstream ss;
		ss << "i = " << i << " : " << typeid(C).name();
		return ss.str();
	}
};

template<typename T>
class MyClass
{
private:
	unique_ptr<T> u_ptr;
	friend MyClass<Base>;
public:
	MyClass(int k)
	{
		u_ptr = make_unique<T>(k);
	}
	template<typename M>
	MyClass(const M& obj)
	{
		u_ptr = make_unique<M>(obj);
	}
	template<typename M>
	MyClass(const M&& obj)
	{
		u_ptr = make_unique<M>(obj);
	}
	template<typename M>
	MyClass(const MyClass<M>& obj)
	{
		u_ptr = make_unique<M>(*obj.u_ptr);
	}
	template<typename M>
	MyClass(MyClass<M>&& obj)
	{
		u_ptr = std::forward<MyClass<M>>(obj).u_ptr;
	}

	void print()
	{
		cout << u_ptr->get_status() << endl;
	}
};

int main()
{
	cout << "--------------------" << endl;
	{
		vector<MyClass<Base>> result;
		{
			vector<MyClass<Base>> v;
			v.reserve(10);

			v.emplace_back(1);
			v.emplace_back<B>(2);
			auto c = C(3);
			v.emplace_back(c);

			v.emplace_back(MyClass<Base>(4));
			v.emplace_back<MyClass<B>>(5);
			auto d = MyClass<C>(6);
			v.emplace_back(d);

			for (auto& obj : v) obj.print();
			std::reverse(begin(v), end(v));
			result = move(v);
		}
		cout << "--------------------" << endl;
		for (auto& obj : result) obj.print();
	}
	cout << "--------------------" << endl;

	return 0;
}

コード:

--------------------
~B(),~Base() : i = 2
i = 1 : class Base
i = 2 : class B
i = 3 : class C
i = 4 : class Base
i = 5 : class B
i = 6 : class C
~C(),~Base() : i = 6
~C(),~Base() : i = 3
--------------------
i = 6 : class C
i = 5 : class B
i = 4 : class Base
i = 3 : class C
i = 2 : class B
i = 1 : class Base
~C(),~Base() : i = 6
~B(),~Base() : i = 5
~Base() : i = 4
~C(),~Base() : i = 3
~B(),~Base() : i = 2
~Base() : i = 1
--------------------

コード:

--------------------
~B(),~Base() : i = 2
i = 1 : 4Base
i = 2 : 1B
i = 3 : 1C
i = 4 : 4Base
i = 5 : 1B
i = 6 : 1C
~C(),~Base() : i = 6
~C(),~Base() : i = 3
--------------------
i = 6 : 1C
i = 5 : 1B
i = 4 : 4Base
i = 3 : 1C
i = 2 : 1B
i = 1 : 4Base
~C(),~Base() : i = 6
~B(),~Base() : i = 5
~Base() : i = 4
~C(),~Base() : i = 3
~B(),~Base() : i = 2
~Base() : i = 1
--------------------

コード:

struct Base;//純粋仮想クラス

コード:

#include <iostream>
#include <string>
#include <sstream>
#include <memory>
#include <vector>
#include <algorithm>
#include <type_traits>

using namespace std;

class Base
{
public:
	virtual ~Base() = 0;
	virtual string get_status() = 0;
};

inline Base::~Base() {}

class A : public Base
{
protected:
	int i;
public:
	A(int i) : i(i) {}
	A(const A& obj) : i(obj.i) {}
	~A() { cout << "~A(): i = " << i << endl; }

	string get_status() override
	{
		stringstream ss;
		ss << typeid(A).name() << " : " << "i = " << i;
		return ss.str();
	}
};

class B : public Base
{
protected:
	string s;
public:
	B(string s) : s(s) {}
	B(const B& obj) : s(obj.s) {}
	~B() { cout << "~B(): s = " << s << endl; }

	string get_status() override
	{
		stringstream ss;
		ss << typeid(B).name() << " : " << "s = " << s;
		return ss.str();
	}
};

template<typename T>
class MyClass
{
private:
	std::unique_ptr<T> u_ptr;
	friend MyClass<std::common_type_t<Base,T>>;
public:
	MyClass(int i) : u_ptr(make_unique<T>(i)) {}
	MyClass(const char* s) : u_ptr(make_unique<T>(s)) {}
	MyClass(string s) : u_ptr(make_unique<T>(s)) {}
	template<typename M> MyClass(const M& obj) : u_ptr(make_unique<M>(obj)) {}
	template<typename M> MyClass(const M&& obj) : u_ptr(make_unique<M>(obj)) {}
	template<typename M> MyClass(const MyClass<M>& obj) : u_ptr(make_unique<M>(*obj.u_ptr)) {}
	template<typename M> MyClass(MyClass<M>&& obj) : u_ptr(std::forward<MyClass<M>>(obj).u_ptr) {}

	void print() { cout << u_ptr->get_status() << endl; }
};

int main()
{
	cout << "--------------------" << endl;
	{
		vector<MyClass<Base>> result;
		{
			vector<MyClass<Base>> v;
			v.reserve(10);

			//v.emplace_back(1);
			v.emplace_back<A>(2);
			auto c = B("hello");
			v.emplace_back(c);

			//v.emplace_back(MyClass<Base>(4));
			v.emplace_back<MyClass<A>>(5);
			auto d = MyClass<B>("world");
			v.emplace_back(d);

			for (auto& obj : v) obj.print();
			std::reverse(begin(v), end(v));
			result = move(v);
		}
		cout << "--------------------" << endl;
		for (auto& obj : result) obj.print();
	}
	cout << "--------------------" << endl;

	return 0;
}

コード:

--------------------
~A(): i = 2
class A : i = 2
class B : s = hello
class A : i = 5
class B : s = world
~B(): s = world
~B(): s = hello
--------------------
class B : s = world
class A : i = 5
class B : s = hello
class A : i = 2
~B(): s = world
~A(): i = 5
~B(): s = hello
~A(): i = 2
--------------------

コード:

--------------------
~A(): i = 2
1A : i = 2
1B : s = hello
1A : i = 5
1B : s = world
~B(): s = world
~B(): s = hello
--------------------
1B : s = world
1A : i = 5
1B : s = hello
1A : i = 2
~B(): s = world
~A(): i = 5
~B(): s = hello
~A(): i = 2
--------------------