Establecer el valor predeterminado de la matriz dinámica

Question

Este código creará una matriz de 100 elementos y establecerá el valor de cada uno como falso.

bool boolArray[100] = false; 

¿Cómo puedo establecer el valor predeterminado de una matriz dinámica?

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

Answer 1

En C++ estándar como predeterminados a inicializar casi cualquier cosa, incluyendo la matriz:

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

programa completo que también comprueba el resultado, y desasigna la matriz:

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; 
} 

Ya sea que su compilador aceptará o incluso hará lo correcto es otro asunto.

Por lo tanto, en la práctica, si se siente una necesidad irresistible de utilizar una matriz prima, entonces tal vez un mejor uso std::fill o algo así, o incluso un bucle prima.

Pero tenga en cuenta las repetidas delete[] -expresiones. Tal código redundante es muy fácil equivocarse: es Evil ™. Y hay muchas otras cosas que pueden salir mal con el uso de matrices en bruto, por lo que, como novato, simplemente diga No ™ en matrices en bruto y punteros sin procesar, etc.

En su lugar, use contenedores de biblioteca estándar, que administran correctamente la asignación, inicialización, copia y desasignación –. Sin embargo, hay un pequeño problema con eso, es decir, una optimización prematura en std::vector<bool>, que de lo contrario sería la elección natural. Básicamente, std::vector<bool> usa solo un bit por valor, por lo que no puede distribuir referencias a los elementos bool, sino que distribuye los objetos proxy & hellip;

Por lo tanto, para bool elementos, use p. Ej. a std::bitset (cuando el tamaño se conoce en tiempo de compilación), o p. un std::deque, de la siguiente manera:.

#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; 
} 

Saludos & HTH,

Answer 2

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

Answer 3

Uso std::fill function o std::fill_n function.

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

Nota al margen: trate de usar std::vector lugar.

Answer 4

¿Qué hay de:

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; 
}