produit cartésien de deux espaces vectoriels

Question

Il y a quelques jours, j'ai trouvé un problème intéressant qui se lit comme suit:

Étant donné deux espaces vectoriels génèrent l'ensemble résultant de son produit cartésien. \begin{regrouper} \text{Soit : } \mathcal{V}, \mathcal{W} \text{ être des espaces vectoriels}\\ \mathcal{V} \times \mathcal{W} = \{ (v,w ) \mid v \in \mathcal{V} \land w \in \mathcal{W} \} \end{gather}

• Indice 1 : Un espace vectoriel est un ensemble d'éléments appelés vecteurs qui accomplit certaines propriétés
• Indice 2 : Concevez la solution pour des espaces vectoriels finis
• Astuce 1 : Il est recommandé d'utiliser des structures
• Contrainte : Il vous est interdit d'utiliser n'importe quelle classe stl

J'ai résolu ce problème avec l'approche suivante:

struct vector_pair
{
    double *vector_a;
    double *vector_b;
    size_t a_dimension;
    size_t b_dimension;
};

struct cartesian_product_set
{
    vector_pair *pairs;
    size_t pairs_number;
};

cartesian_product_set vector_spaces_cartesian_product(double **space_v, size_t v_vectors,
    size_t v_dimension, double **space_w, size_t w_vectors, size_t w_dimension)
{
    cartesian_product_set product_set{new vector_pair[v_vectors * w_vectors], v_vectors * w_vectors};
    
    for (size_t i = 0, j, k = 0; i < v_vectors; i++)
        for (j = 0; j < w_vectors; j++)
            product_set.pairs[k++] = vector_pair{space_v[i], space_w[j], v_dimension, w_dimension};

    return product_set;
}

Comment pourrais-je améliorer ce code si possible?

Merci.

Answer 1

1. const-exactitude
2. utiliser des références en faveur des pointeurs si possible
3. Le fait que vous laissiez l'obligation de libérer la mémoire que vous allouez à l'appelant n'est généralement pas une bonne pratique
4. un modèle commun dans votre code est que vous avez des pointeurs vers des tableaux et leur longueur - pourquoi ne pas créer une structure pour les regrouper ?
5. essayez d'utiliser des itérateurs et des boucles basées sur la plage lorsque vous n'avez pas vraiment besoin de l'index (ce que vous n'avez pas dans votre exemple)
6. puisque nous ne nous soucions pas vraiment du type des éléments dans un espace vectoriel, vous pouvez utiliser des modèles pour généraliser votre algorithme

Et juste pour voir si ce serait possible, j'ai essayé de proposer une version compilée de l'algorithme :

template<typename T>
struct pair
{
    T first;
    T second;
};

template<std::size_t N, typename T>
struct cvp
{
    pair<T> pairs[N];
};

template <typename T, size_t NV, size_t NW>
auto get_cvp(const T (&vs)[NV], const T (&ws)[NW])
{
    cvp<NV*NW, T> result;
    auto it_pairs = std::begin(result.pairs);
    for (const auto v : vs) {
        for (const auto w : ws) {
            *(it_pairs++) = {v, w};
        }
    }
    return result;
}

tu peux essayer le code ici:https://godbolt.org/z/e8GvEf