Différence entre const std::array<T,N> et std::array<const T, N>.

Question

Y a-t-il une différence pratique entre std::array<const T, N> y const std::array<T, N> ?

Il semble que les tableaux non constants contenant des éléments constants ne peuvent toujours pas être échangés ; l'opérateur d'affectation ne fonctionne pas non plus.

Quand dois-je préférer l'un à l'autre ?

#include <array>

std::array<const int, 5> array_of_const = {1,2,3,4,5};
std::array<const int, 5> array_of_const2 = {1,2,3,4,5};

const std::array<int, 5> const_array = {1,2,3,4,5};
const std::array<int, 5> const_array2 = {1,2,3,4,5};

int main()
{
    // Assignment doesn't work for either
    array_of_const = array_of_const2;
    const_array = const_array2;

    // Swapping doesn't work for either
    array_of_const.swap(array_of_const2);
    const_array.swap(const_array2);

    // Indexing...
    array_of_const[0] = 0;
    const_array[0] = 0;

    return 0;
};

Answer 1

Copies de std::array<const T, N> sont toujours "logiquement const", alors que par défaut une copie de const std::array<T, N> est mutable. Si permettre ou empêcher cela est important pour vous, l'un est préférable à l'autre.

Il y a des différences dans les modèles qu'ils correspondent, par exemple, le cas dans Réponse d'Ilya .

Answer 2

Il pourrait y avoir au moins une différence - le cas où vous devez passer une variable à une autre fonction, par exemple :

#include <array>

std::array<const int, 5> cc_arr5 = {1,2,3,4,5};
const std::array<int, 5> cc_arr5_2 = {1,2,3,4,5};

template<class T, std::size_t N>
void func(std::array<T, N>& a) {
    // do not change a, for example just calculate sum
}

int main()
{
    func(cc_arr5);
    func(cc_arr5_2); // this line does not compile

    return 0;
};

Answer 3

Il s'agit en effet de types différents, de sorte que vous ne pouvez pas utiliser l'un d'eux à un endroit où l'autre serait attendu, par exemple dans un appel de fonction ou une affectation.

Ceci étant dit, comme un tableau est un conteneur de taille fixe sans membre de données auxiliaire, avoir le conteneur const empêche toute modification de ses éléments et avoir les éléments const ne permet aucune modification du conteneur puisqu'il n'a évidemment aucun autre membre de données.

En d'autres termes, les deux types auront les mêmes opérations valides et invalides.

La principale différence à laquelle je peux penser, c'est la const_cast implication : un tableau peut être (implicitement) converti en un tableau const du même type d'élément mais pas en un tableau du type const modifié :

std::array<int, 3> a {1, 2, 3};

std::array<const int, 3> b = a; // Error: no known conversion from 'array<int, [...]>' to 'const array<const int, [...]>
const std::array<int, 3> c = a; // Ok