Próbuję zrozumieć szablony wyrażeń, implementując własną klasę tablicy wielowymiarowej. Zasadniczo alokuję ciągły chuck pamięci, a następnie obliczam przesunięcia za pomocą operatora ().

Teraz chcę przeciążyć +,/,*,- szablonami wyrażeń. Przykład zilustrowany w wikipedii jest dość ilustracyjny, ale zakłada, że ​​datablock jest typu double. Chciałbym mieć typ danych jako parametr szablonu. Próbowałem to wdrożyć, ale zawsze mi się to nie udaje. Tak wygląda dotychczasowy kod:

    namespace ader{

    template<class E, typename T> class vexp{
        inline unsigned size()const{return static_cast<E const&>(*this).size();};
        inline T operator[](const unsigned &i) const{ return static_cast<E const&>(*this)[i];}
    };

// ***************************************************************************** // 

    template<class E1, class E2, typename T>
        class vsum:
        public vexp<vsum<E1,E2,T>,T>{
        const E1 &_u;
        const E2 &_v;
        public:
        vsum(const E1 &u, const E2 &v): _u(u), _v(v){};
        inline T operator[](const unsigned &i)const {return _u[i] + _v[i];};
        inline unsigned size()const{return _u.size();};
    };


// ***************************************************************************** // 


    template<typename T, unsigned nDer> class aDer: public ader::vexp<aDer<T,nDer>,T>{
        protected:
        unsigned n;
        T d[nDer+1];

        public:
        unsigned size()const{return n;};

        T  operator[](const unsigned &i)     {return d[i];};
        T &operator[](const unsigned &i)const{return d[i];};

        aDer():n(nDer), d{0}{};
        aDer(const T &in): n(nDer), d{0}{d[0] = in;};
        aDer(const T &in, const unsigned &idx): n(nDer), d{0}{d[0] = in; d[idx+1] = T(1);};
        template<template<typename,unsigned> class U> aDer(const vexp<U<T,nDer>,T> &in){
            for(unsigned ii=0; ii<=nDer; ++ii) d[ii] = in[ii];
        }
    };

    template< class E1, class E2, typename T>
        vsum<E1,E2,T> operator+(const E1 &u, const E2 &v){return vsum<E1,E2,T>(u,v);};


};

Komunikat o błędzie:

main2.cc: In function ‘int main()’:
main2.cc:15:27: error: no match for ‘operator+’ (operand types are ‘ader::aDer<float, 2>’ and ‘ader::aDer<float, 2>’)
ader::aDer<float,2> c= a+b;

Czy w kodzie jest coś wyraźnie nie tak?

EDIT1: zawartość main2.cc:

#include "aut2.h"
#include <iostream>

using namespace std;

int main(){

    ader::aDer<float,2> a(1.220334, 1);
    ader::aDer<float,2> b(3.0, 0);

    ader::aDer<float,2> c= a+b;

    cerr<<c[0]<<endl;

}
0
JdlCR 4 listopad 2018, 12:06

1 odpowiedź

Najlepsza odpowiedź

Twój operator+ ma nieodliczalny parametr T. Musisz pozbyć się tego parametru i wywnioskować T z E1 i E2.

Jednym ze sposobów na osiągnięcie tego byłoby zdefiniowanie operator+ w następujący sposób:

template <class E1, class E2>
auto operator+(const E1 &u, const E2 &v) -> vsum<E1, E2, decltype(u[0] + v[0])>
{
    return { u,v };
}

Innym sposobem byłoby całkowite pozbycie się parametru T we wszystkich klasach, używając zamiast tego auto i decltype(auto):

template <class E> class vexp {
    ...
    inline decltype(auto) operator[](const unsigned &i) const { return static_cast<E const&>(*this)[i]; }
};

W powyższym kodzie operator[] zwróci każdy typ zwracany przez E::operator[].

Zwróć uwagę, że decltype(auto) i auto bez specyfikacji typu końcowego zwracanego jest funkcją C++14.

1
r3mus n0x 4 listopad 2018, 13:22