Question

我在C ++中很陌生。我写了一个函数模板来求和向量中的所有元素，像这样：

template<typename T>
inline T sumator(const std::vector<T> &sequence) {
    T init = T{};
    return accumulate(sequence.begin(), sequence.end(), init);
}

一切正常，直到未声明默认构造函数，而是从例如2个参数声明构造函数为止。像这样：

class A {
    private:
        int a;
        int b;
    public:
//        A() = default;
        A(int aa, int bb) : a(aa),b(bb){};
        A operator+(const A &right) const {
            return {a + right.a, b + right.b};
        }
        bool operator==(const A &right) const {
            return (a == right.a && b == right.b);
        }

    };
    vector<A> bc = {{3,5},{5,5}};
    A res = Adder::sumator(works);
    A result = {8,10};
    assert(result,res);

现在我得到一个类似的错误：错误：没有匹配的构造函数来初始化'A' T init = T {};

如何避免这种情况，而不使用https://en.cppreference.com/w/cpp/types/is_default_constructible

UPD：我有很多类，其中有些具有默认构造函数，有些没有但带有2 arg的构造函数，有些带有3，等等。而且我想很好地积累每种情况

Answer 1

我能想到的可能的解决方案。

让用户通过提供初始vlaue来依靠std::accumulate。
为sumator提供一个带有初始值的重载。如果用户的类型没有默认的构造函数，则可以使用初始值调用重载。
坚持要为其调用函数的类型具有默认构造函数。

template<typename T>
inline T sumator(const std::vector<T> &sequence, T init) {
    return accumulate(sequence.begin(), sequence.end(), init);
}

template<typename T>
inline T sumator(const std::vector<T> &sequence) {
    return accumulate(sequence.begin(), sequence.end(), {});
}

Answer 2

您可以使用默认参数添加另一个参数。

template<typename T>
inline T sumator(const std::vector<T> &sequence, const T& init = T{}) {
    return accumulate(sequence.begin(), sequence.end(), init);
}

对于类型可能是默认构造的，您仍然可以

sumator(some_vector);

并在T无法默认构造时指定默认值。例如

sumator(some_vector, A{0, 0});

Answer 3

您可以将其分成两个重载，并添加static_assert以在有人尝试以错误的方式使用它时提供不错的编译错误消息。

仅当类型是默认可构造类型时，一次重载才有效，并且对于不及以下类型的类型，一次重载将有效：

#include <type_traits>
#include <vector>

template<typename T>
T sumator(const std::vector<T>& sequence) {
    static_assert(std::is_default_constructible_v<T>);
    return std::accumulate(sequence.begin(), sequence.end(), T{});
}

template<typename T>
T sumator(const std::vector<T>& sequence, const T& init) {
    return std::accumulate(sequence.begin(), sequence.end(), init);
}

另一种选择是添加一个默认参数，该参数可用于默认可构造的类型-您还可以使其更通用，使其不仅可以与vector一起使用，而且可以与list一起使用s等。

template<template<class, class...> class C, class T, class... Ts>
T sumator(const C<T, Ts...>& sequence, const T& init = T{}) {
    return std::accumulate(sequence.begin(), sequence.end(), init);
}

模板默认初始化，如果类中没有默认构造函数

3 个答案: