Implémentation d'un constructeur efficace et pratique pour un modèle de classe vectorielle C ++

Le moyen le plus pratique de procéder serait d'utiliser un guide de déduction, en modifiant votre exemple d'utilisation donné:

#include <iostream>
#include <vector>
#include <array>

using u16 = unsigned short const;

template <typename T, u16 N>
struct Vector : std::array<T, N> {
    Vector<T, N> operator + (Vector<T, N> & rightVector) {
        decltype(auto) self = *this;
        Vector<T, N> sumVec;

        for ( ushort i = 0; i < N; ++i ) {
            sumVec[i] = self[i] + rightVector[i];
        }

        return sumVec;
    }

    Vector operator += (Vector const& rightVector) {
        decltype(auto) self = *this;

        for ( ushort i = 0; i < N; ++i ) {
            self[i] += rightVector[i];
        }

        return this;
    }

    Vector operator ++ () {
        decltype(auto) self = *this;

        for ( T& item : self ) {
            ++item;
        }

        return this;
    }

    Vector operator ++ (int const) {
        decltype(auto) self = *this;

        Vector temporary = self;

        ++self;

        return temporary;
    }


    Vector operator - (Vector const& rightVector) const {
        decltype(auto) self = *this;

        Vector<T, N> sumVec;

        for ( ushort i = 0; i < N; ++i ) {
            sumVec[i] = self[i] - rightVector[i];
        }

        return Vector(sumVec);
    }
};

int main() {
    using vector_t = Vector<double, 2>;

    vector_t x = { 1.0, 2.0 };
    vector_t y = { 9.0, 3.0 };
    vector_t z = x + y; // { 10.0. 4.0 }

    std::wcout << z[0] << ", " << z[1] << '\n';
}

en quelque chose de beaucoup plus simple:

using ushort = unsigned short;

template <typename T, ushort N>
using Vector = T __attribute__((
    vector_size(sizeof(T) * N) //  the number of bytes in a single `T`, multiplied by the number of elements, `N`
));

int main() {
    using vector_t = Vector<double const, 2>;

    vector_t x = { 1.0, 2.0 };

    vector_t y = { 9.0, 3.0 };

    vector_t z = x + y;

    std::wcout << z[0] << ", " << z[1] << '\n'; // "10, 5\n"
}

Activation d'une utilisation similaire à std::array .

Le moyen le plus simple et le plus efficace de créer un vecteur de taille statique permettant cela serait sans doute d'utiliser un __attriubute__ C ++ non standard.

En modélisant le T __attribute__((vector_size(N))) , nous nous retrouvons avec ce qui suit:

Vector<double, 2> myVec = { 1.0, 2.0 };

// or even
// Vector myVec = { 1.0, 2.0 };

Ok, d'accord, je plaisante, ne fais pas ça, n'abordons pas le monde des attributs, des extensions de compilateur et du code non portable.

Le moyen le plus simple de le rendre aussi pratique à utiliser que le std::array sous-jacent serait soit de créer un guide de déduction de type, d'hériter de std::array , soit de ne pas implémenter un constructeur, les deux derniers autorisant le std::array constructeur de std::array prend effet, car la classe n'a pas de constructeur en soi.

Je pense que, dans ce cas, vous pourrez peut-être simplement hériter de std::array , sans énerver tous les développeurs C ++ sur SO.

Quelque chose du genre:

using Vec2D = Vector<double, 2>;
Vec2D myVec = Vec2D({1.0, 2.0});

std::enable_if , vous voudrez peut-être utiliser quelques std::enable_if ou assertions pour vous assurer de ne créer que des vecteurs de type numérique, car cela semble être ce que vous voulez utiliser.

Cela devrait avoir la même utilisation de la mémoire qu'un std::array . Il n'initialise aucun type supplémentaire, contrairement à votre exemple qui avait construit std::vector s partout.

Cela correspond-il à votre utilisation et à vos objectifs prévus?

Vous pouvez également utiliser des packs de paramètres, qui (combinés à un polymorphisme sympa) peuvent vous permettre de faire des choses comme ceci:

#include <vector>
#include <array>
#include <algorithm>
#include <cassert>

template <typename T, size_t n>
struct Vector : std::array<T, n>
{
    /* Default constructor, needed as recursion endpoint */
    Vector() = default;

    /* Recursive constructor that takes an arbitrary number of arguments
     * Dangerous: only adds the last n arguments */
    template <typename... Ts>
    Vector(T v, Ts... args) : Vector(args...) { addItem(v); };

    /* Vector constructor that takes an arbitrary std::vector v
     * Dangerous: only adds the first n items */
    template <typename T2>
    explicit Vector(const std::vector<T2>& v) : added{std::min(v.size(), n)}
    {
        assert(v.size() == n);
        for (size_t i = 0; i < added; i++)
        {
            (*this)[i] = (T)v[i];
        }
    }

    /* Copy constructor: takes a Vector of any type, but of the same length */
    template <typename T2>
    Vector(const std::array<T2, n>& v) : added{n}
    {
        for (size_t i = 0; i < added; i++)
        {
            (*this)[i] = (T)v[i];
        }
    }

    /* Example of a polymorphic addition function */
    template <typename T2>
    Vector<T, n> operator+(const Vector<T2, n>& v)
    {
        Vector<T, n> vr{*this};
        for (size_t i = 0; i < n; i++)
        {
            vr[i] += (T)v[i];
        }
        return vr;
    }

private:
    size_t added{0};

    /* Needed for recursive constructor */
    void addItem(const T& t)
    {
        added++;
        if (added <= n) { (*this)[n - added] = t; }
        else { assert(false); }
    }
};

Où Vector est défini comme suit:

Vector<int, 3> v1{std::vector<int>{1, 2, 3}};
Vector<double, 3> v2 = {5., 6., 7.};
Vector<float, 3> v3 = v1 + v2;

Vous pouvez directement utiliser les paramètres pour initialiser la classe de base

Code non testé.

template <typename... Args>
Vector(Args...&& args) : mEVector(std::forward<Args>(args)...) { };