Définir la valeur par défaut du tableau dynamique

Question

Ce code créera un tableau de 100 éléments et définira la valeur de chacun à false.

bool boolArray[100] = false; 

Comment puis-je définir la valeur par défaut d'une matrice dynamique?

void Foo(int size) 
{ 
    bool boolArray = new bool[size]; 
    //Now what? 
} 

Answer 1

Dans la norme C++, vous pouvez par défaut initialiser à peu près tout, y compris ce tableau:

bool* boolArray = new bool[size]();  // Zero-initialized 

programme complet qui vérifie également le résultat, et désalloue le tableau:

bool foo(int size) 
{ 
    bool* boolArray = new bool[size]();  // Zero-initialized 

    // Check that it is indeed zero-initialized: 
    for(int i = 0; i < size; ++i) 
    { 
     if(boolArray[i]) { delete[] boolArray; return false; } 
    } 
    delete[] boolArray; return true; 
} 

#include <iostream> 
int main() 
{ 
    using namespace std; 
    cout << (foo(42)? "OK" : "Ungood compiler") << endl; 
} 

Que votre le compilateur acceptera ou même fera la bonne chose est une autre affaire.

Ainsi, dans la pratique, si vous vous sentez une envie irrésistible d'utiliser un tableau brut, puis utilisez peut-être mieux std::fill ou un tel, ou même une boucle brute.

Mais notez les delete[] -expressions répétées. Un tel code redondant est très facile à se tromper: c'est le mal ™. Et il y a beaucoup d'autres choses qui peuvent mal se passer avec l'utilisation des tableaux bruts, donc en tant que novice, il suffit de dire Non ™ aux tableaux bruts et aux pointeurs bruts et autres. À la place, utilisez des conteneurs de bibliothèque standard, qui gèrent correctement l'allocation, l'initialisation, la copie et la désallocation pour vous –. Il y a un petit problème avec cela, à savoir, une optimisation prématurée dans std::vector<bool>, qui autrement serait le choix naturel. Essentiellement std::vector<bool> utilise juste un bit par valeur, de sorte qu'il ne peut pas distribuer des références aux éléments bool, mais à la place distribue des objets proxy & hellip;

Ainsi, pour les éléments bool, utilisez par ex. std::bitset (lorsque la taille est connue au moment de la compilation), ou par ex. un std::deque, comme suit:.

#include <deque> 

bool foo(int size) 
{ 
    std::deque<bool> boolArray(size);  // Zero-initialized 

    for(int i = 0; i < size; ++i) 
    { 
     if(boolArray[i]) { return false; } 
    } 
    return true; 
} 

#include <iostream> 
int main() 
{ 
    using namespace std; 
    cout << (foo(42)? "OK" : "Ungood compiler") << endl; 
} 

Vive & HTH,

Answer 2

bool* boolArray = new bool[size]; 
for(int i = 0; i < size; i++) { 
    boolArray[i] = false; 
} 

Answer 3

Utilisez std::fill function ou std::fill_n function.

std::fill_n(boolArray, length, defaultValue); 
std::fill(boolArray, boolArray + length, defaultValue); 

Side note: essayez d'utiliser std::vector à la place.

Answer 4

Qu'en est-:

void Foo(int size) 
{ 
    // bool boolArray = new bool[size]; 
    // Did you mean bool*? 
    // Try and avoid direct allocation of memory. 
    // Memory allocation should be done inside an object that 
    // actively manages it. 

    // Normally I would recommend a vector 
    std::vector<bool> boolArray(size, false); 

    // But. And a Big but. Is that the standards committee decided to 
    // specialize the vector for bool so that each element only takes 
    // a single bit. Unfortunately this had some side effects that were 
    // made its use not perfect (time/assign-ability). 

    // So we can try a boost array 
    boost::array<bool, size> boolArray; 
}