C++ 指针总结

1 指针引用

引用不可以改变指向，对一个对象"至死不渝"；但是指针可以改变指向，而指向其它对象。说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容

Ep:错误用法

将指针p传入函数Malloc的参数p_val时，p_val = p 指向同一块内存。修改p_val 的值等同于修改p的值。

但是p_val = malloc 时，将p_val 指向了新申请的那块内存，p和p_val不再指向同一块内存。

 

修改为引用：p_val指向p的引用，修改p_val等同于修改p

2 取得成员函数指针

class A {

public:

       void Func(int a) {printf("func a = %d \n" ,a);}

};

int main()

{

       //::*是一个特殊的操作符，表示pFunc是一个指针，指向A的成员函数。

       //获取成员函数的地址不能通过类对象来获取，必须像上面的那样，

       //通过类名获取，而且要加上取地址操作符（&）。

       void (A::*pFunc)(int) = &A::Func;

       A a;

       (a.*pFunc)(10);//通过对象本身来调用

 

       A* pa = &a;

       (pa->*pFunc)(11);//通过对象指针来调用

       return 0;

}

第一种方式是通过对象本身来调用，第二种方式是通过对象指针来调用，两种方式的效果都是一样的。.*和->*都是特殊的操作符，不必纠结于它们奇怪的样子，只要知道它们只用于调用成员函数指针就行了。

 

3 使用类模板-成员函数指针

 

class A {

public:

       void Func(int a) {printf("func a = %d \n" ,a);}

};

 

class B

{

public:

       void Method(int b) {printf("func b = %d \n" ,b);}

};

 

template<typename T>//类模板

class DelegateHandler

{

public:

       DelegateHandler(T* pT, void (T::*pFunc)(int)) :

                     m_pT(pT), m_pFunc(pFunc)

       {

       }

       void Invoke(int value)

       {

              (m_pT->*m_pFunc)(value);

       }

private:

       T* m_pT;//对象指针

       void (T::*m_pFunc)(int);//类成员函数指针

};

 

 

int main()

{

       //::*是一个特殊的操作符，表示pFunc是一个指针，指向A的成员函数。

       //获取成员函数的地址不能通过类对象来获取，必须像上面的那样，

       //通过类名获取，而且要加上取地址操作符（&）。

       A a;

       DelegateHandler<A> ah(&a, &A::Func);

       ah.Invoke(3);

 

       B b;

       DelegateHandler<B> bh(&b, &B::Method);  //B::Method的声明与A::Func一致

       bh.Invoke(4);

 

       return 0;

}

 

4 模板偏特化-非成员函数指针

void NonmemberFunc(int f)

{

       printf("NonmemberFunc f = %d \n" ,f);

}

 

template<>

class DelegateHandler<void>

{

public:

       DelegateHandler(void (*pFunc)(int)): m_pFunc(pFunc) { }

 

       void Invoke(int value)

       {

              (*m_pFunc)(value);

       }

 

private:

       void (*m_pFunc)(int);

};

 

5 多态委托

将各种类型的DelegateHandler放到同一个容器中，并使用同样的方式来调用

class A {

public:

    void Func(int a) {printf("func a = %d \n" ,a);}

};

 

class B

{

public:

    void Method(int b) {printf("func b = %d \n" ,b);}

};

 

class IDelegateHandler

{

 

public:

    virtual ~IDelegateHandler() { }

    virtual void Invoke(int) = 0;

};

 

 

template<typename T>//类模板

class DelegateHandler : public IDelegateHandler//delegate 委托

{

public:

    DelegateHandler(T* pT, void (T::*pFunc)(int)) :

            m_pT(pT), m_pFunc(pFunc)

    {

    }

 

    void Invoke(int value)

    {

        (m_pT->*m_pFunc)(value);

    }

private:

    T* m_pT;//对象指针

    void (T::*m_pFunc)(int);//类成员函数指针

};

 

void NonmemberFunc(int h)

{

    printf("NonmemberFunc h = %d \n" ,h);

}

 

template<>

class DelegateHandler<void> : public IDelegateHandler

{

public:

    DelegateHandler(void (*pFunc)(int)): m_pFunc(pFunc) { }

 

    void Invoke(int value)

    {

        (*m_pFunc)(value);

    }

 

private:

    void (*m_pFunc)(int);

};

 

int main()

{

    A a;

    B b;

 

    DelegateHandler<A> ah(&a, &A::Func);

    DelegateHandler<B> bh(&b, &B::Method);

    DelegateHandler<void> vh(NonmemberFunc);

 

    //将各种类型的DelegateHandler放到同一个容器中，并使用同样的方式来调用了

    std::vector<IDelegateHandler*> handlers;

    handlers.push_back(&ah);

    handlers.push_back(&bh);

    handlers.push_back(&vh);

 

    for (auto it = handlers.begin(); it != handlers.end(); ++it) {

        (*it)->Invoke(7);

    }

    return 0;

}