#include
#include
#include
#include
#include
#include
class Any {
public:
//notice this!
template
using StorageType = typename std::decay::type;
template>::value
&& !std::is_same>::value>::type>
Any(Ty&& value) :container(new Container>(std::forward(value)))
{
std::cout<< "constructor" <container != nullptr) { delete (this->container); this->container = other.clone(); }else { this->container = other.clone();
}
}
Any(Any&& other)
{
if (this->container != nullptr) { delete (this->container); this->container = other.container; }else { this->container = other.container;
} other.container = nullptr;
} Any& operator=(Any&& other)
{
if (this->container == nullptr) { this->container = other.container; }else { delete (this->container); this->container = other.container;
} other.container = nullptr;
}
Any& operator=(const Any& other)
{
if (this->container != nullptr) { delete (this->container); (this->container) = other.clone(); }else { (this->container) = other.clone();
}
return *this;
}
Any() :container(nullptr) {}
~Any()
{
if (container != nullptr)
{ delete container; (this->container) = nullptr;
}
}
/*
template
Ty getValue()const noexcept
{
if ((this->container) == nullptr) { std::runtime_error("There is nothing!"); } Container>* derived = dynamic_cast>*>(this->container); return (derived->data);
}*/
template
Ty getValue()
{
if ((this->container) == nullptr) { std::runtime_error("There is nothing!"); } std::cout << "test" <* derived = dynamic_cast*>(this->container);
std::cout << "derived-data: " << derived->data << std::endl; return (derived->data);
}
/*
template
operator Ty&()
{ /*auto*/
//std::function function = static_cast(&Any::getValue); //Cotainer>* contain = dynamic_cast>*>(this->container); //return (contain->data);
//}
/*template
operator Ty()const
{
std::function function = static_cast(&Any::getValue);
return (this->*function());
}*/
private:
class ContainerBase {
public:
ContainerBase() = default;
ContainerBase(const ContainerBase& ) = default;
ContainerBase(ContainerBase&& ) = default;
ContainerBase& operator=(const ContainerBase& )=default;
ContainerBase& operator=(ContainerBase&& )=default; virtual ~ContainerBase() = default; virtual ContainerBase* clone()const noexcept = 0; //pure-virtual function.
};
template
class Container : public ContainerBase {
public: Type data; Container(Type&& value_) :ContainerBase(),data(value_) {}
Container(const Type& value_) :ContainerBase(),data(value_) {}
Container(const Container& other):ContainerBase(other),data(other.data){}
Container(Container&& other):ContainerBase(other),data(std::move(other.data)){} Container& operator=(const Container& other)
{ ContainerBase::operator=(other); this->data = other.data;
} Container& operator=(Container&& other)
{ ContainerBase::operator=(other); this->data = other.data;
} virtual ~Container() = default; virtual ContainerBase* clone()const noexcept override
{ return (new Container>(this->data));
}
};
ContainerBase* clone()const noexcept
{
if (this->container == nullptr) { return nullptr; }else { return (this->container)->clone();
}
}
ContainerBase* container;
};
class Eplace_back {
public:
Eplace_back() = default;
~Eplace_back() = default;
Eplace_back(const Eplace_back& other) = delete;
Eplace_back& operator=(const Eplace_back& other) = delete;
template
void operator()(std::vector& vec, Ty&& value)
{
std::cout << "pus value in vector" << std::endl;
vec.emplace_back(std::forward(value));
}
};
int main()
{
std::vector myVector;
Eplace_back emplace_back;
emplace_back(myVector, 100);
emplace_back(myVector, 200); std::cout << myVector[0].getValue() << std::endl;
std::cout << myVector[1].getValue() << std::endl; std::cout<< "xxxxxxxxxxxx" <
转载于:https://my.oschina.net/SHIHUAMarryMe/blog/543551
