C++: typedefs

Question

vektör ve matris çoğalması için aşağıdaki kod kod parçasını göz önünde değiştirilmesi halinde olacağına dair belirsizliklerin olası aşırı yük çözülebilir:

#include <array> 

template<typename T,size_t N> using vec = std::array<T,N>; 

template<typename T,size_t N,size_t M> using mat = vec<vec<T,M>,N>; 

template<typename T,typename U,size_t N> 
vec<T,N> operator*(const vec<T,N>& a,const vec<U,N>& b){ 
    return {}; //implement componentwise mult. 
} 

template<typename T,typename U,size_t N,size_t M,size_t L> 
mat<T,L,M> operator*(const mat<T,N,M>& a,const mat<U,L,N>& b){ 
    return {}; //implement matrix mult. 
} 

int main(){ 
    mat<float,4,4> a,b; 
    auto c = a * b; 
} 

ikinci bir açık matrislerini kullanır 2 operator* aşırı yükleri, tanımlar.

Bu, GCC 5.2'da "aşırı yükleme" hatasıyla sonuçlanacaktır, ancak bence ikinci aşırı yük ilkinden daha fazla uzmanlıktır.

Ben şimdi ikinci aşırı yük typedefs değiştirin:

mat<T,L,M> operator*(const mat<T,N,M>& a,const mat<U,L,N>& b)

olur:

mat<T,L,M> operator*(const vec<vec<T,M>,N>& a,const vec<vec<U,N>,L>& b)

Düzenleme:

Ben küçük yazım hatası yaptı ... Çözünürlük neden işe yaradı thats, bendeğiştive L, dolayısıyla b türü const vec<vec<U,L>,N>& b idi.

Sadece bu yazım hatası ile aşırı yüklenme normal olarak çözülebilir.

Sorum şu: Bu davranış standart veya hata tarafından iyi tanımlanmış mı? VS2015 ile

Answer 1

:

Error C2593 'operator *' is ambiguous 

Belirsizliği içinde

kodunuzu

template<typename T, typename U, size_t N> 
vec<T, N> operator*(const vec<T, N>& a, const vec<U, N>& b) { 
    return{}; //implement componentwise mult. 
} 

template<typename T, typename U, size_t N, size_t M, size_t L> 
mat<T, L, M> operator*(const mat<T, N, M>& a, const mat<U, L, N>& b) { 
    return{}; //implement matrix mult. 
} 

sonuç vec<T, N> operator*(const vec<T, N>& a, const vec<U, N>& b) T bir vec<T,M> olarak yorumlanabilir olmasından kaynaklanmaktadır.

Ve değişmez

template<typename T, typename U, size_t N> 
vec<T, N> operator*(const std::array<T, N>& a, const std::array<U, N>& b) { 
    return{}; //implement componentwise mult. 
} 


template<typename T, typename U, size_t N, size_t M, size_t L> 
mat<T, L, M> operator*(const vec<vec<T, M>, N>& a, const vec<vec<U, N>, L>& b) { 
    return{}; //implement matrix mult. 
} 

sonuç ile önerdiği gibi ben bunların yerine eğer.

Error C2593 'operator *' is ambiguous 

Çözümünüzden emin misiniz? Belki de const düşünmüyor musun?