Как использовать объявление функции указателя шаблона typedef без указания шаблона? - PullRequest
Новая
       58

Как использовать объявление функции указателя шаблона typedef без указания шаблона?

1 голос
/ 06 марта 2020 
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;



enum Op{ADD, SUB, MUL, DIV, MATMUL};

template <typename dtype>
using AlgoFunction = double(*)(const vector<dtype> &, Op);

// for example, the sum function doesn't require template.
// just write sum(a), not sum<float>(a)
template <typename dtype>
double sum(vector<dtype> inputs) {
    dtype summer = inputs[0];
    for (int i=1; i<inputs.size(); i++) summer = summer + inputs[i];
    return double(summer);
}

// i need to do ask this question because I perform the same
// algorithm (linearAlgo, ...) on different types of data
// (dtype = float, double, matrix<float>, matrix<double>, ...
template <typename dtype>
inline dtype numOperate(const dtype &a, const dtype &b, Op op) {
    if (op==ADD) return a + b;
    if (op==SUB) return a - b;
    if (op==MUL) return a * b;
    if (op==DIV) return a / b;
}


template <typename dtype>
double linearAlgo(const vector<dtype> &inputs, Op op) {
    dtype summer = inputs[0];
    for (int i=1; i<inputs.size(); i++) summer = numOperate(summer, inputs[i], op);
    return double(summer);
}

template <typename dtype>
double reverseLinearAlgo(const vector<dtype> &inputs, Op op) {
    int n = inputs.size();
    dtype summer = inputs[n-1];
    for (int i=n-2; i>=0; i--) summer = numOperate(summer, inputs[i], op);
    return double(summer);
}

template<typename dtype>
vector<double> run(vector<dtype> inputs, Op op, double (*func)(const vector<dtype>&, Op)) {
    vector<double> res;
    res.push_back(func(inputs, op));
    return res;
}

int main()
{
    vector<float> a;
    vector<double> b;
    a.push_back(1); a.push_back(2); a.push_back(3);
    b.push_back(1); b.push_back(2); b.push_back(3);

    vector<double> res = run(a, ADD, linearAlgo);  // allowed without specifying template
    vector<double> resf = run(b, ADD, linearAlgo); // still work with multiple data type


    // I want to do this assignment without specifying the template.
    // in the above linear, linearAlgo (no specifying template) is possible, why not here ?
    AlgoFunction<float> functor = reverseLinearAlgo; // works, but I don't want it
    //AlgoFunction functor = reverseLinearAlgo;   // I want to do this. compile error
    vector<double> res2 = run(a, ADD, functor);

    cout << res[0] << "\n";
    cout << res2[0];
    return 0;
}

Итак, у меня есть указатель шаблона функции 

template <typename dtype>
using AlgoFunction = double(*)(const vector<dtype> &, Op);

, который указывает на подобные функции 

template <typename dtype>
double linearAlgo(const vector<dtype> &inputs, Op op) {
    dtype summer = inputs[0];
    for (int i=1; i<inputs.size(); i++) summer = numOperate(summer, inputs[i], op);
    return double(summer);
}

Я знаю, что использование указателя на функцию шаблона без указания шаблона возможно , Например: 

 vector<float> a;
 a.push_back(1); a.push_back(2); a.push_back(3);    
 vector<double> res = run(a, ADD, linearAlgo); // allowed without specifying template

Но тогда, если я объявлю переменную типа AlgoFunction, компилятор заставит меня указать шаблон. 

//AlgoFunction<float> functor = reverseLinearAlgo; // works, but I don't want it
AlgoFunction functor = reverseLinearAlgo;   // I want to do this. compile error

Это не хорошо, потому что у меня есть много типов данных dtype, и я не хочу снова указывать шаблон для каждого из них.

Так как я могу объявить AlgoFunction functor; вместо AlgoFunction<some_datatype_name> functor;?

Спасибо.

Редактировать: цель состоит в том, чтобы vector<AlgoFunction> functors вместо vector<AlgoFunction<data_type> >. Поскольку в этом примере res и resf могут быть рассчитаны без указания шаблона для 3-го параметра, я хочу знать, возможно ли vector<AlgoFunction> или нет.

Ответы [ 2 ]

2 голосов
/ 06 марта 2020

Вы не можете. Я подозреваю, что путаница связана с отсутствием различия между «функцией» и «шаблоном функции».

Чтобы объяснить, почему ваш первый пример сработал, сначала давайте рассмотрим, что на самом деле происходит, когда вы делаете run(a, ADD, linearAlgo);. Напомним, что у нас есть: 

template <typename dtype>
using AlgoFunction = double(*)(const std::vector<dtype>&, Op);

template <typename dtype>
std::vector<double> run(const std::vector<dtype>&, Op, 
                        double(*)(const std::vector<dtype>&, Op));

Эквивалентно, мы могли бы иметь следующее: 

std::vector<double> run(const std::vector<dtype>&, Op, AlgoFunction<dtype>);

, поскольку AlgoFunction это просто псевдоним.

Теперь когда мы делаем это: 

std::vector<double> a;
run(a, ADD, linearAlgo);

мы знаем, что первый аргумент run, std::vector<dtype>, это std::vector<double>, и, следовательно, dtype это double. Мы ничего не можем определить относительно dtype по третьему аргументу, поскольку linearAlgo - это просто шаблон, «шаблон».

Поскольку мы знаем, что dtype должно быть double, мы можем выбрать и создайте экземпляр linearAlgo<dtype> - то есть linearAlgo<double> - как нашу функцию, поскольку она соответствует нашей подписи, и все в порядке.

Теперь, как это связано с этим? 

AlgoFunction functor = reverseLinearAlgo;

В этом случае мы пытаемся создать переменную. reverseLinearAlgo - это просто шаблон функции, а не фактическая функция, и у нас нет другого контекста, чтобы определить, какой тип functor на самом деле. Отсюда ошибка компилятора.

Кроме того, что бы это на самом деле означало? Будет ли functor иметь другой тип в зависимости от того, где вы его использовали? Если бы я сделал auto x = functor;, какой бы тип имел x? Если бы я сделал что-то вроде 

AlgoFunction functor = reverseLinearAlgo;
if (test) {
  std::vector<float> x;
  functor(x, ADD);
} else {
  std::vector<double> x;
  functor(x, ADD);
}

, значит ли это, что functor имеет тип Dynami c? Это не то, что работает с системой типов C ++ (stati c), и может быстро выйти из-под контроля, если это будет сделано законным. Это случай с вашим wi sh для std::vector<AlgoFunction>: вы должны хранить конкретный тип. В противном случае программе потребуется динамически создавать функцию на основе информации времени выполнения: параметры шаблона должны быть известны во время компиляции.

Одна из возможных альтернатив, если вы знаете типы заранее, - это использовать std::variant из возможных типов, с которыми вы можете создать экземпляр. То есть что-то вроде 

std::vector<std::variant<AlgoFunction<float>, AlgoFunction<double>>>;

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

std::vector<std::tuple<AlgoFunction<float>, AlgoFunction<double>>>;

, если каждый элемент вектора должен использоваться с type.

Полезно ли это и стоит ли сложность, решать только вам.

1 голос
/ 06 марта 2020

Можно делать то, что вы хотите, но это сложно реализовать в C ++, потому что вы должны выполнять ручную проверку типов, если вы хотите серьезно реализовать что-то подобное.

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

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct AlgoFunction {
    virtual double operator()(void *) = 0;
};

template <class T>
struct AF_Sum : public AlgoFunction {
    virtual double operator()(void * inputVec) {
        T res = T();
        vector<T>* pInput = (vector<T>*)inputVec;
        for (int i = 0; i < pInput->size(); ++i) {
            res += (*pInput)[i];
        }

        return (double) res;
    }
};

template <class T>
struct AF_Mean : public AlgoFunction {
    virtual double operator()(void * inputVec) {
        T res = T();
        vector<T>* pInput = (vector<T>*)inputVec;
        for (int i = 0; i < pInput->size(); ++i) {
            res += (*pInput)[i];
        }

        return (double) res / (double)pInput->size();
    }
};

int main()
{
    std::vector<float> vF{0.2, 0.3, 0.8};
    std::vector<int> vI{2, 5, 7};

    std::vector<AlgoFunction*> algoFunctions;

    algoFunctions.push_back(new AF_Sum<float>);
    algoFunctions.push_back(new AF_Mean<int>);

    cout << (*algoFunctions[0])(&vF) << endl;
    cout << (*algoFunctions[1])(&vI) << endl;

    return 0;
}

Обратите внимание, что я не сделал не надо чистить выделенную кучу память (через новую), и я не реализовал все ваши функции; просто быстрый и грязный пример потенциального решения.

...