如何使用 c++ 中的模板调用非成员 function，其中 typename 仅在返回中？

Question

My goal is to have a non member function use a template for a return value. This is so I can return a float array, a double array, etc. I get a "couldn't deduce template parameter 'T'" error.

Here is the method I am trying to use:

template<typename T>
T* make(double magnitude, double frequency, double radians, double seconds,
        int samplesPerSecond) {
    long samples = length(seconds, samplesPerSecond);
    T *wave = new T[samples];
    for (int i = 0; i < samples; i++) {
        wave[i] = magnitude
                * sin(
                        (2.0 * (M_PI) * frequency * i / samplesPerSecond)
                                + radians);
    }
    return wave;
}

I first tried to call the method normally.

double *ds = make(magnitude, frequency, radians, seconds, samplesPerSecond);

I have tried adding the typename after the function name.

double *ds = make<double>(magnitude, frequency, radians, seconds, samplesPerSecond);

I looked over several pages on the web and they have all covered member functions so far and explained that the type cannot be deduced from a return type, so how do you tell the compiler the type?

Answer 1

You can very much do this with non-member functions, as per the following example, which adds together two values of a templated type:

#include <iostream>

template<typename T> T add(const T &val1, const T &val2) {
    return val1 + val2;
}

int main() {
    auto eleven = add<int>(4, 7);
    std::cout << "4   + 7   = " << eleven << '\n';
    auto threePointFour = add<double>(1.1, 2.3);
    std::cout << "1.1 + 2.3 =  " << threePointFour << '\n';
}

The output of that code is, as expected:

4   + 7   = 11
1.1 + 2.3 =  3.4

It's possible that your case isn't working because the definition of the templated function may be incorrect - since you haven't supplied that, it's hard to tell for sure. Hence you may want to see how it compares to my own add function as shown above.

---

As an aside (since your heading indicates this may be what you're attempting), you can also do this without using the templated types in the parameter list (only the return type):

#include <iostream>

template<typename T> T addAndHalve(const double &val1, const double &val2) {
    auto x = (val1 + val2) / 2;
    std::cout << "debug " << x << ": ";
    return x;
}

int main() {
    auto eleven = addAndHalve<int>(4, 7);
    std::cout << "(4   + 7  ) / 2 = " << eleven << '\n';
    auto threePointFour = addAndHalve<double>(1.1, 2.3);
    std::cout << "(1.1 + 2.3) / 2 =  " << threePointFour << '\n';
}

You can see this only affects the return value, using double for all parameters:

debug 5.5: (4   + 7  ) / 2 = 5
debug 1.7: (1.1 + 2.3) / 2 =  1.7

Answer 2

I noticed the c++ standard library had functions like lround(), where the l means the function returns a long, so I ended up making multiple methods too.

int16_t* makei(double magnitude, double frequency, double radians,
        double seconds, int samplesPerSecond);
float* makef(double magnitude, double frequency, double radians, double seconds,
        int samplesPerSecond);

This violate the "avoid unnecessary overloading" rule I hear echoed so often, and the following code does indeed work.

double *ds = make<double>(magnitude, frequency, radians, seconds, samplesPerSecond);

I had another unknown error that prevented it from working.