如何区分构造函数

Question

我在一个 class 模板中有两个构造函数，一个带有数组，一个带有向量作为参数。

我有指向给定参数的指针成员。

我必须重载 operator[] 并编写 size() 方法（每个方法只有一个），但我不知道如何区分给定的类型。

如何判断调用了哪个构造函数？

提前致谢。

template<typename T, typename F>
class view {

const T* arrayT;
const std::vector<T>* vectT;
size_t* sizeArray;
F functor{};


view(const T array[], rsize_t sze) {
        arrayT = array; 
        sizeArray = &sze; 
    }

view(const std::vector<T> vect) {
        vectT = &vect;
    }



int size() const{
    if( ?????){
        return sizeArray;
    } else {
        return vecT-> size();
    }
}

T view<T, F>::operator[](int index) const {

     if(????) {
         functor(arrayT[index]);
     } else {
         return functor(vectT->at(index));
     }
}

Answer 1

您可以在 class 级别拥有私有 bool flag，并根据调用的构造函数将其设置为 false 的 true。

差异很容易看出，一个接受两个参数，另一个只接受一个参数，因此可以预测构造函数调用。

class view {
    bool flag;    
    const T* arrayT;
    const std::vector<T>* vectT;
    size_t* sizeArray;
    F functor{};

    /// Accepts two arguments
    view(const T array[], rsize_t sze) {
        flag = true;
        arrayT = array; 
        sizeArray = &sze; 
    }

    /// Accepts one argument
    view(const std::vector<T> vect) {
        flag = false;
        vectT = &vect;
    }

    int size() const {
        if (flag) {
            return sizeArray;
        } else {
            return vecT-> size();
        }
    }

    T view<T, F>::operator[](int index) const {
        if (flag) {
            functor(arrayT[index]);
        } else {
            return functor(vectT->at(index));
        }
    }
}

Answer 2

如果你正在做 c++17，我建议你看看 constexpr if https://en.cppreference.com/w/cpp/language/if#Constexpr_If

这是一种新的语言功能，可以让您在编译时执行 if。

Answer 3

你不应该使用两个指针。您也可以定义更多的构造函数。

template<typename T, typename F>
class view {
    const T* arr;
    size_t size;
    F functor;

    view(const T arr[], size_t size) : arr(arr), size(size) {}

    template <size_t N>
    view(const T (&arr)[N]) : arr(arr), size(N) {}

    view(const std::vector<T> & vec) : arr(vec.data()), size(vec.size()) {}

    template <size_t N>
    view(const std::array<T, N> & arr) : arr(arr.data()), size(N) {}

    int size() const { return size; }

    std::invoke_result_t<F, T> operator[](int index) const { return functor(arrayT[index]); }
};

如何区分构造函数

How to differentiate between constructors

c++

templates

pointers

return-type