C ++ шаблон мета-программирования кунг-фу вызов (замена определения макро-функции) - PullRequest
Новая
       6

C ++ шаблон мета-программирования кунг-фу вызов (замена определения макро-функции)

11 голосов
/ 22 июля 2010

Ситуация

Я хочу реализовать составной шаблон: 

class Animal
{
public:
    virtual void Run() = 0;
    virtual void Eat(const std::string & food) = 0;
    virtual ~Animal(){}
};

class Human : public Animal
{
public:
    void Run(){ std::cout << "Hey Guys I'm Running!" << std::endl; }
    void Eat(const std::string & food)
    {
        std::cout << "I am eating " << food << "; Yummy!" << std::endl;
    }
};

class Horse : public Animal
{
public:
    void Run(){ std::cout << "I am running real fast!" << std::endl; }
    void Eat(const std::string & food)
    {
        std::cout << "Meah!! " << food << ", Meah!!" << std::endl;
    }
};

class CompositeAnimal : public Animal
{
public:
    void Run()
    {
        for(std::vector<Animal *>::iterator i = animals.begin();
            i != animals.end(); ++i)
        {
            (*i)->Run();
        }
    }

    // It's not DRY. yuck!
    void Eat(const std::string & food)
    {
        for(std::vector<Animal *>::iterator i = animals.begin();
            i != animals.end(); ++i)
        {
            (*i)->Eat(food);
        }
    }

    void Add(Animal * animal)
    {
        animals.push_back(animal);
    }

private:
    std::vector<Animal *> animals;
};

Проблема

Видите ли, для моего простого требования составного шаблона я в итогеписать много одного и того же повторяющегося кода, повторяющегося в одном и том же массиве.

Возможное решение с помощью макросов 

#define COMPOSITE_ANIMAL_DELEGATE(_methodName, _paramArgs, _callArgs)\
    void _methodName _paramArgs                                      \
    {                                                                \
        for(std::vector<Animal *>::iterator i = animals.begin();     \
            i != animals.end(); ++i)                                 \
        {                                                            \
            (*i)->_methodName _callArgs;                             \
        }                                                            \
    }

Теперь я могу использовать его следующим образом: 

class CompositeAnimal : public Animal
{
public:
    // It "seems" DRY. Cool

    COMPOSITE_ANIMAL_DELEGATE(Run, (), ())
    COMPOSITE_ANIMAL_DELEGATE(Eat, (const std::string & food), (food))

    void Add(Animal * animal)
    {
        animals.push_back(animal);
    }

private:
    std::vector<Animal *> animals
};

Вопрос

Есть ли способ сделать это "чище" с помощью метапрограммирования C ++?

Более сложный вопрос

std::for_each был предложен в качестве решения.Я думаю, что наша проблема здесь является частным случаем более общего вопроса, давайте рассмотрим наш новый макрос: 

#define LOGGED_COMPOSITE_ANIMAL_DELEGATE(_methodName, _paramArgs, _callArgs)\
    void _methodName _paramArgs                                      \
    {                                                                \
        log << "Iterating over " << animals.size() << " animals";    \
        for(std::vector<Animal *>::iterator i = animals.begin();     \
            i != animals.end(); ++i)                                 \
        {                                                            \
            (*i)->_methodName _callArgs;                             \
        }                                                            \
        log << "Done"                                                \
    }

Похоже, это не может быть заменено на for_each

Последствия

Глядя на отличный ответ GMan, эта часть C ++ определенно нетривиальна.Лично, если мы просто хотим уменьшить объем стандартного кода, я думаю, что макросы, вероятно, являются подходящим инструментом для работы в данной конкретной ситуации.

GMan предложил std::mem_fun и std::bind2nd для возврата функторов.К сожалению, этот API не поддерживает 3 параметра (я не могу поверить, что что-то подобное было выпущено в STL).

В качестве иллюстрации, вот функции делегата, использующие boost::bind вместо: 

void Run()
{
    for_each(boost::bind(&Animal::Run, _1));
}

void Eat(const std::string & food)
{
    for_each(boost::bind(&Animal::Eat, _1, food));
}

Ответы [ 2 ]

10 голосов
/ 22 июля 2010

Я не уверен, что действительно вижу проблему, как таковую.Почему бы не что-то вроде: 

void Run()
{
    std::for_each(animals.begin(), animals.end(),
                    std::mem_fun(&Animal::Run));
}

void Eat(const std::string & food)
{
    std::for_each(animals.begin(), animals.end(),
                    std::bind2nd(std::mem_fun(&Animal::Eat), food));
}

Не так уж плохо.

Если вы действительно хотите избавиться от (маленького) стандартного кода, добавьте: 

template <typename Func>
void for_each(Func func)
{
    std::for_each(animals.begin(), animals.end(), func);
}

В качестве частного члена утилиты используйте это: 

void Run()
{
    for_each(std::mem_fun(&Animal::Run));
}

void Eat(const std::string & food)
{
    for_each(std::bind2nd(std::mem_fun(&Animal::Eat), food));
}

Чуть более лаконично.Нет необходимости в метапрограммировании.

На самом деле метапрограммирование в конечном итоге потерпит неудачу.Вы пытаетесь генерировать функции, которые определены в текстовом виде.Мета-программирование не может генерировать текст, поэтому вы неизбежно будете использовать где-то макрос для генерации текста.

На следующем уровне вы напишите функцию, а затем попытаетесь извлечь шаблонный код.std::for_each делает это довольно хорошо.И, конечно, как было продемонстрировано, если вы обнаружите, , что слишком много повторений, просто проясните это.

В ответ на пример LoggedCompositeAnimal вкомментарий, ваш лучший выбор - сделать что-то похожее на: 

class log_action
{
public:
    // could also take the stream to output to
    log_action(const std::string& pMessage) :
    mMessage(pMessage),
    mTime(std::clock())
    {
        std::cout << "Ready to call " << pMessage << std::endl;
    }

    ~log_action(void)
    {
        const std::clock_t endTime = std::clock();

        std::cout << "Done calling " << pMessage << std::endl;
        std::cout << "Spent time: " << ((endTime - mTime) / CLOCKS_PER_SEC)
                    << " seconds." << std::endl;
    }

private:
    std::string mMessage;
    std::clock_t mTime;
};

, который просто в основном автоматически регистрирует действия.Тогда: 

class LoggedCompositeAnimal : public CompositeAnimal
{
public:
    void Run()
    {
        log_action log(compose_message("Run"));
        CompositeAnimal::Run();
    }

    void Eat(const std::string & food)
    {
        log_action log(compose_message("Eat"));
        CompositeAnimal::Eat(food);
    }

private:
    const std::string compose_message(const std::string& pAction)
    {
        return pAction + " on " +
                    lexical_cast<std::string>(animals.size()) + " animals.";
    }
};

Вот так. Информация о lexical_cast .

2 голосов
/ 22 июля 2010

Вы можете создать функторы вместо методов: 

struct Run
{
    void operator()(Animal * a)
    {
        a->Run();
    }
};

struct Eat
{
    std::string food;
    Eat(const std::string& food) : food(food) {}

    void operator()(Animal * a)
    {
        a->Eat(food);
    }
};

И добавить CompositeAnimal::apply (#include <algorithm>): 

template <typename Func>
void apply(Func& f)
{
    std::for_each(animals.begin(), animals.end(), f);
}

Тогда ваш код будет работать так: 

int main()
{
    CompositeAnimal ca;
    ca.Add(new Horse());
    ca.Add(new Human());

    Run r;
    ca.apply(r);

    Eat e("dinner");
    ca.apply(e);
}

Вывод: 

> ./x
I am running real fast!
Hey Guys I'm Running!
Meah!! dinner, Meah!!
I am eating dinner; Yummy!

Чтобы интерфейс оставался согласованным, вы можете пойти еще дальше.

Переименовать структуру Run в Running иstruct Eat до Eating для предотвращения столкновения метода / структуры.

Тогда CompositeAnimal::Run будет выглядеть так, используя метод apply и struct Running: 

void Run()
{
    Running r;
    apply(r);
}

И аналогично CompositeAnimal::Eat: 

void Eat(const std::string & food)
{
    Eating e(food);
    apply(e);
}

И вы можете позвонить сейчас: 

ca.Run();
ca.Eat("dinner");

вывод все тот же: 

I am running real fast!
Hey Guys I'm Running!
Meah!! dinner, Meah!!
I am eating dinner; Yummy!
...