Состав: использование черт, чтобы избежать пересылки функций?

Может быть, вы можете попробовать частное наследование:

class Person : private ContactInfo
{
public:
Person() { }
using ContactInfo::updateAddress;
using ContactInfo::updatePhone;
using ContactInfo::updateEmail;
};

int main()
{
Person person;
person.updateAddress("hi");
return 0;
}

Хотя вы можете не упускать из виду предостережения, перечисленные в этом Часто задаваемые вопросы:

Есть также несколько различий:

• Вариант простой композиции необходим, если вы хотите содержать несколько двигателей на автомобиль
• Вариант частного наследования может привести к ненужному множественному наследованию
• Вариант частного наследования позволяет членам Car преобразовать автомобиль * в двигатель *
• Вариант частного наследования позволяет получить доступ к защищенным членам базового класса.
• Вариант частного наследования позволяет Car переопределять виртуальные функции Engine
• Вариант приватного наследования упрощает (20 символов по сравнению с 28 символами) метод Car ()
  это просто вызывает метод start () Engine

В остальном пример представленной композиции кажется идентичным вашему. Нажатие на ссылку черты в статье в Википедии не предоставило никаких статей C ++, и ссылка в ссылках, кажется, о type traits, Я не мог найти как type traits имеет какое-либо отношение к вашему сценарию.

В статье рассказывается о наследовании с Интерфейс,

так на самом деле это говорит о том, что объект должен уважать некоторые подписи.

черты типа можно использовать для проверки правильности подписи и отправки в соответствующую функцию

Например, некоторые алгоритмы STL ждут тип Итератор,
но эти итераторы не наследуют от class Iterator но должен предоставить какой-то контракт (operator ++(), operator !=(rhs), operator*()).

с примером статьи:

• Класс Player — который может двигаться
• Класс здания — который не может двигаться

И код:

#if 1
// simple type traits which tells if class has method update_position
template <typename T> struct can_move;

// Hardcode the values
template <> struct can_move<Player> { static const bool value = true; };
template <> struct can_move<Building> { static const bool value = false; };

#else
// or even better, but need a has_update_position. (see how to check if member exist in a class)
template <typename T> struct can_move{ static const bool value = has_update_position<T>::value };
#endif

template <typename T, bool> struct position_updater;

// specialization for object which can move
template <typename T> struct position_updater<T, true>
{
static void update(T& object) { object.update_position(); }
};

// specialization for object which can NOT move
template <typename T> struct position_updater<T, false>
{
static void update(T& object) { /* Do nothing, it can not move */ }
};template <typename T>
void update_position(T& object)
{
// statically dispatch to the correct method
// No need of interface or inheritance
position_updater<T, can_move<T>::value>::update(object);
}

AFAIK класс черт что-то вроде следующего:

#include <iostream>
using namespace std;

class ContactInfo
{
public:
void updateAddress() { cout << "update address"; };
void updatePhone() {};
void updateEmail() {};
};

template<class T> class TraitClass
{
public:

private:
T obj;
};

template<> class TraitClass<ContactInfo>
{
public:
void updateAddress() {obj.updateAddress();};
void updatePhone() {obj.updatePhone();};
void updateEmail() {obj.updateEmail();};
private:
ContactInfo obj;
};

class Person
{
public:
void updateAddress() {obj.updateAddress();};
void updatePhone() {obj.updatePhone();};
void updateEmail() {obj.updateEmail();};
private:
TraitClass<ContactInfo> obj;
};

int main() {

Person myPerson;

myPerson.updateAddress();

return 0;
}

То есть: шаблонный класс во время компиляции, где вы можете реализовать (и / или специализировать его) ваши методы делегата, чтобы пересылать все, что вам нужно, без (по какой бы то ни было причине) повторения наследования.

http://en.wikipedia.org/wiki/Trait_(computer_programming)