如何區分構造函數

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

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

這是一種新的語言功能，可以讓您在編譯時執行。

Answer 2

您可以在 class 級別擁有一個私有bool flag ，並根據被調用的構造函數將其設置為true或false 。

可以很容易地看到差異，因為它們一個接受兩個參數，另一個只接受一個參數，因此可以預測構造函數調用。

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 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]); }
};