Initialiser tous les éléments d'un tableau au même nombre

Question

Il y a quelque temps, mon ancien professeur a posté ce code en disant que c'était une autre façon d'initialiser un tableau au même nombre (autre que zéro bien sûr).

Trois dans ce cas.

Il a déclaré que cette méthode était légèrement meilleure que celle de la for boucle. Pourquoi ai-je besoin de l'opérateur de décalage vers la gauche ? Pourquoi ai-je besoin d'un autre tableau de long ? Je ne comprends rien à ce qui se passe ici.

int main() {

    short int A[100];

    long int v = 3;
    v = (v << 16) + 3;
    v = (v << 16) + 3;
    v = (v << 16) + 3;
    long *B = (long*)A;

    for(int i=0; i<25; i++)
        B[i] = v;

    cout << endl;
    print(A,100);
}

Answer 1

Il existe de nombreuses façons de remplir un tableau avec la même valeur, et si vous vous préoccupez des performances, vous devez les mesurer.

Le C++ dispose d'une fonction spécifique pour remplir un tableau avec une valeur, et je l'utiliserais (après la fonction #include <algorithm> y #include <iterator> ) :

std::fill(std::begin(A), std::end(A), 3);

Il ne faut pas sous-estimer ce que les compilateurs optimisants peuvent faire avec ce genre de choses.

Si vous souhaitez voir ce que fait le compilateur, vous pouvez consulter l'article de Matt Godbolt intitulé Explorateur de compilateur est un très bon outil si vous êtes prêt à apprendre un peu d'assembleur. Comme vous pouvez le voir dans aquí Les compilateurs peuvent optimiser la fill appel à douze (et un peu plus) magasins de 128 bits avec toutes les boucles déroulées. Comme les compilateurs connaissent l'environnement cible, ils peuvent le faire sans encoder dans le code source des hypothèses spécifiques à la cible.

Answer 2

Il part du principe que long est quatre fois plus long que le short (ce qui n'est pas garanti ; il devrait utiliser int16_t et int64_t).

Il prend cet espace mémoire plus long (64 bits) et le remplit avec quatre valeurs courtes (16 bits). Il configure les valeurs en décalant les bits de 16 espaces.

Il souhaite ensuite traiter un tableau de shorts comme un tableau de longs, de manière à pouvoir définir 100 valeurs de 16 bits en effectuant seulement 25 itérations de boucle au lieu de 100.

C'est ce que pense votre professeur, mais comme d'autres l'ont dit, ce casting est un comportement non défini.

Answer 3

C'est une véritable foutaise.

1. Pour commencer, v sera calculée à temps de compilation .

2. Le comportement du déréférencement B suivants long *B = (long*)A; est indéfinie car les types ne sont pas liés. B[i] est un déréférencement de B .

3. Il n'y a aucune justification à l'hypothèse selon laquelle un long est quatre fois plus grand qu'un short .

Utiliser un for de manière simple et faire confiance au compilateur pour l'optimisation. S'il vous plaît, avec du sucre sur le dessus.

Answer 4

La question comporte la balise C++ (pas de balise C), ce qui signifie qu'elle doit être réalisée dans le style C++ :

// C++ 03
std::vector<int> tab(100, 3);

// C++ 11
auto tab = std::vector<int>(100, 3);
auto tab2 = std::array<int, 100>{};
tab2.fill(3);

De plus, le professeur essaie d'être plus malin que le compilateur qui peut faire des choses époustouflantes. Il n'y a aucun intérêt à faire de tels tours puisque le compilateur peut le faire pour vous s'il est configuré correctement :

• Vos assemblages de code
• Vos assemblages de code avec le tick enlevé
• Approche par réseau
• Approche vectorielle

Comme vous pouvez le constater, le -O2 Le code de résultat est (presque) le même pour chaque version. Dans le cas de -O1 Les astuces permettent d'améliorer la situation.

En fin de compte, vous devez faire un choix :

• Écrire un code difficile à lire et ne pas utiliser les optimisations du compilateur
• Écrire un code lisible et utiliser -O2

Utilisez le site Godbolt pour expérimenter d'autres compilateurs et configurations. Voir aussi le dernier discours de la cppCon .

Answer 5

Comme expliqué dans d'autres réponses, le code viole les règles d'aliasing de type et fait des suppositions qui ne sont pas garanties par la norme.

Si vous souhaitiez vraiment effectuer cette optimisation à la main, il s'agirait d'une méthode correcte au comportement bien défini :

long v;
for(int i=0; i < sizeof v / sizeof *A; i++) {
    v = (v << sizeof *A * CHAR_BIT) + 3;
}

for(int i=0; i < sizeof A / sizeof v; i++) {
    std:memcpy(A + i * sizeof v, &v, sizeof v);
}

Les hypothèses peu sûres concernant la taille des objets ont été fixées par l'utilisation de sizeof et la violation de l'aliasing a été corrigée par l'utilisation de std::memcpy qui a un comportement bien défini quel que soit le type sous-jacent.

Cela dit, il est probablement préférable de garder votre code simple et de laisser le compilateur faire sa magie.

---

Pourquoi ai-je besoin de l'opérateur de gauche ?

Il s'agit de remplir un entier plus grand avec plusieurs copies de l'entier plus petit. Si vous écrivez une valeur de deux octets s en un grand nombre entier l alors changement les bits restants pour deux octets (ma version corrigée devrait être plus claire sur l'origine de ces nombres magiques) alors vous aurez un entier avec deux copies des octets qui constituent la valeur s . Cette opération est répétée jusqu'à ce que toutes les paires d'octets dans l sont fixés à ces mêmes valeurs. Pour effectuer le décalage, vous avez besoin de l'opérateur de décalage.

Lorsque ces valeurs sont copiées sur un tableau contenant un tableau d'entiers de deux octets, une seule copie fixe la valeur de plusieurs objets à la valeur des octets de l'objet le plus grand. Comme chaque paire d'octets a la même valeur, il en va de même pour les plus petits entiers du tableau.

Pourquoi ai-je besoin d'un autre tableau de long ?

Il n'y a pas de tableaux de long . Seul un tableau de short .