CodingMayhem Jun 10 2015 at 18:52

Передача сохраненных аргументов в функцию

5 min

15K

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

Первое решение основано на том, что С++ уже предоставляет нам механизм захвата переменных. Речь идет о лямбдах. Естественно, что самым очевидным и простым было бы использовать такой чудесный механизм. Для тех, кто не знаком с С++14 и выше, я приведу соответствующий код:

auto Variable = 1;

auto Lambda = [Variable]() {
    someFunction(Variable);
};

В этом коде создается лямбда функция, которая захватывает переменную с именем Variable. Сам объект лямбда функции копируется в переменную с именем Lambda. Именно через эту переменную в дальнейшем можно будет вызывать саму лямбда функцию. И такой вызов будет выглядеть совсем как вызов обычной функции:

Lambda();

Казалось бы, что поставленная задача уже решена, но в реальности это не так. Лямбда функцию можно вернуть из функции, метода или другой лямбды, но передать ее потом куда-то не используя шаблонов затруднительно.

auto makeLambda(int Variable) {
    return [Variable]() {
        someFunction(Variable);
    };
}

auto Lambda = makeLambda(3);

// Какой должна быть сигнатура функции, принимающей такой аргумент?
someOtherFunction(Lambda);

Лямда функции являются объектами какого-то анонимного типа, у них есть известная лишь только компилятору внутренняя структура. И чистый С++ (я имею ввиду язык без библиотек) предоставляет программисту не так уж и много операций над лямбдами:

лямбду можно вызвать;
лямбду можно привести к указателю на функцию, если эта лямбда не захватыает переменные;
лямбду можно скопировать.

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

#include <utility>
#include <cstdint>
#include <vector>

template <typename Function> class SignalTraits;

template <typename R, typename... A> class SignalTraits<R(A...)> {
public:
  using Result = R;
};

template <typename Function> class Signal {
public:
  using Result = typename SignalTraits<Function>::Result;

  template <typename Callable> Signal(Callable Fn) : Storage(sizeof(Fn)) {
    new (Storage.data()) Callable(std::move(Fn));

    Trampoline = [](Signal *S) -> Result {
      auto CB = static_cast<Callable *>(static_cast<void *>(S->Storage.data()));
      return (*CB)();
    };
  }

  Result invoke() { return Trampoline(this); }

private:
  Result (*Trampoline)(Signal *Self);

  std::vector<std::uint8_t> Storage;
};

В этом примере: благодаря шаблонному конструктору, лямбда создаваемая внутри этого конструктора будет иметь информацию о типе Сallable, а значит, сможет привести данные в Storage к нужному типу. Фактически, в этом и заключается весь фокус. Вся сложная работа по захвату переменных и вызову функций и лямбд возложена на плечи компилятора. На мой взгляд, такое решение предельно простое и элегантное.

Что же касается второго решения, то оно мне нравится меньше, т.к. в нем очень много самописного кода, который решает по сути то, что уже решено для нас компилятором. А именно: захват переменных. Не буду вдаваться в долгие рассуждения и обсуждения, а приведу сразу код всего решения. Т.к. он очень большой и мне не импанирует, то я его спрячу под кат:

не красивый код.

#include <cstdarg>
#include <cstdint>
#include <vector>

template <typename T> struct PromotedTraits { using Type = T; };
template <> struct PromotedTraits<char> { using Type = int; };
template <> struct PromotedTraits<unsigned char> { using Type = unsigned; };
template <> struct PromotedTraits<short> { using Type = int; };
template <> struct PromotedTraits<unsigned short> { using Type = unsigned; };
template <> struct PromotedTraits<float> { using Type = double; };

template <typename... Arguments> class StorageHelper;

template <typename T, typename... Arguments>
class StorageHelper<T, Arguments...> {
public:
  static void store(va_list &List, std::vector<std::uint8_t> &Storage) {
    using Type = typename PromotedTraits<T>::Type;
    union {                                       
      T Value;                                    
      std::uint8_t Bytes[sizeof(void *)];         
    };                                            
    Value = va_arg(List, Type);
    for (auto B : Bytes) {
      Storage.push_back(B);
    }
    StorageHelper<Arguments...>::store(List, Storage);
  }
};

template <> class StorageHelper<> {
public:
  static void store(...) {}
};

template <bool, typename...> class InvokeHelper;

template <typename... Arguments> class InvokeHelper<true, Arguments...> {
public:
  template <typename Result>
  static Result invoke(Result (*Fn)(Arguments...), Arguments... Args) {
    return Fn(Args...);
  }
};

template <typename... Arguments> class InvokeHelper<false, Arguments...> {
public:
  template <typename Result> static Result invoke(...) { return {}; }
};

struct Dummy;

template <std::size_t Index, typename... Types> class TypeAt {
public:
  using Type = Dummy *;
};

template <std::size_t Index, typename T, typename... Types>
class TypeAt<Index, T, Types...> {
public:
  using Type = typename TypeAt<(Index - 1u), Types...>::Type;
};

template <typename T, typename... Types> class TypeAt<0u, T, Types...> {
public:
  using Type = T;
};

template <typename Function> class Signal;

template <typename Result, typename... Arguments>
class Signal<Result(Arguments...)> {
public:
  using CFunction = Result(Arguments...);

  Signal(CFunction *Delegate, Arguments... Values) : Delegate(Delegate) {
    initialize(Delegate, Values...);
  }

  Result invoke() {
    std::uintptr_t *Args = reinterpret_cast<std::uintptr_t *>(Storage.data());
    Result R = {};
    using T0 = typename TypeAt<0u, Arguments...>::Type;
    using T1 = typename TypeAt<0u, Arguments...>::Type;
    // ... and so on.
    switch (sizeof...(Arguments)) {
    case 0u:
      return InvokeHelper<(0u == sizeof...(Arguments)),
                          Arguments...>::template invoke<Result>(Delegate);
    case 1u:
      return InvokeHelper<(1u == sizeof...(Arguments)),
                          Arguments...>::template invoke<Result>(Delegate,
                                                                 (T0 &)Args[0]);
    case 2u:
      return InvokeHelper<(2u == sizeof...(Arguments)),
                          Arguments...>::template invoke<Result>(Delegate,
                                                                 (T0 &)Args[0],
                                                                 (T1 &)Args[1]);
      // ... and so on.
    }
    return R;
  }

private:
  void initialize(CFunction *Delegate, ...) {          
    va_list List;                                      
    va_start(List, Delegate);                          
    StorageHelper<Arguments...>::store(List, Storage); 
    va_end(List);                                      
  }                                                    

  CFunction *Delegate;

  std::vector<std::uint8_t> Storage; 
};

Тут вся интересность, на мой взгляд, заключается в двух вспомогательных классах: StorageHelper и InvokeHelper. Первый комбинирует эллипсис и рекурсивный проход по списку типов для того, чтобы заполнить хранилище аргументов. Второй предоставляет безопасный в плане типов способ извлечения аргументов из этого хранилища. Кроме того, есть еще одна небольшая хитрость: эллипсис промоутит одни типы к другим. Т.е. float переданный через… будет приведен к double, char к int, short к int и т.д.

Хочу подвести этакий итог всему выше сказанному. По моему мнению, оба решения не идеальны: они много чего не умеют и пытаются изобрести колесо. Если бы меня спросили как правильно захватить аргументы и передать их в некую функцию, я бы не раздумывая сказал, что нужно использовать std::function + лямбду. Хотя в качестве упражнения для ума поставленная задачка очень даже неплоха.

Надеюсь, что все прочитанное вами окажется полезным. Спасибо, что так далеко дочитали!

Tags:

Hubs: