헤더파일


#pragma once

#include <iostream>


using namespace std;


template <typename BaseType, typename BaseTargetType>

class MemPtrBase

{

public:

virtual BaseTargetType& value(BaseType& obj) const = 0;

virtual BaseTargetType const& value(BaseType const& obj) const = 0;


protected:

MemPtrBase() {}

virtual ~MemPtrBase() {};


private:

MemPtrBase(MemPtrBase const&);

MemPtrBase& operator=(MemPtrBase const&);

};


template <typename BaseType, typename BaseTargetType, typename TargetType>

class TypedMemPtr : public MemPtrBase<BaseType, BaseTargetType>

{

TargetType BaseType::* p;


public:

TypedMemPtr(TargetType BaseType::* ptr)

: p(ptr)

{}


BaseTargetType& value(BaseType& obj) const

{

return obj.*p;

}


BaseTargetType const& value(BaseType const& obj) const

{

return obj.*p;

}

};


template <typename BaseType, typename BaseTargetType>

class MemPtr // this is a handle only

{

MemPtrBase<BaseType, BaseTargetType>* p;


public:

template <typename BaseType2, typename TargetType>

explicit MemPtr(TargetType BaseType2::* ptr)

: p(new TypedMemPtr<BaseType, BaseTargetType,

TargetType>(static_cast<TargetType BaseType::*>(ptr)))

{}


~MemPtr()

{

delete p;

}


BaseTargetType& value(BaseType& obj) const

{

return p->value(obj);

}


BaseTargetType const& value(BaseType const& obj) const

{

return p->value(obj);

}

};


class Animal

{

public:


typedef Animal* (*NewAnimalFunction)();


virtual void MakeNoise()

{

std::cout << "Animal!" << std::endl;

}

};


class Dog : public Animal

{

public:


typedef void(Dog::* BarkFunction)();


typedef Dog* (*NewDogFunction)();


Dog() {}


static Dog* NewDog()

{

return new Dog;

}


virtual void MakeNoise()

{

std::cout << "Woof!" << std::endl;

}

};


cpp 파일

#include "Reflection.h"


int main()

{

Animal tmpAnimal;

Dog Animal::* pDogAnimal = nullptr;

TypedMemPtr<Animal, Animal, Dog>* pTypedMem = new TypedMemPtr<Animal, Animal, Dog>(pDogAnimal);

pTypedMem->value(tmpAnimal).MakeNoise();


// Call member function via method pointer

Dog* pDog = new Dog();


// void(Dog:: * ptr)()

Dog::BarkFunction pBark = &Dog::MakeNoise;

(pDog->*pBark)();


// Construct instance via factory method

// Dog* (*ptr)()

Dog::NewDogFunction pNew = &Dog::NewDog;

Animal* pAnimal = (*pNew)();

pAnimal->MakeNoise();


delete pDog;

return 0;

}






코드 분석 답글로 남기면 상품줌