如何比 for 循环更有效地初始化数组？ C++

Question

Currently, I am initializing arrays by creating for loops and setting arr[I] = 0. Is there another way to do this more efficiently?

Student::Student(){
    
    name = "John";
    for(int i = 0; i<sizeof(id);++i)
    {
        id[i] = '0';
    }
    for(int i = 0; i<sizeof(testScore);++i)
    {
        testScore[i] = 0;
    }
    avgScore = 100;
    grade = 'A';
    
}

Answer 1

You can try Zero initialization .

example:

    int arr1[12] = {}; // values: 000000000000
    std::array<int, 5> arr2 = {}; // values: 00000

This way you can skip the for loop and have a cleaner looking code.

Answer 2

Loop Unrolling

Here is an example of loop unrolling:

const int capacity = sizeof(id) / sizeof(id[0]);
const int fill_value = 0; // hopefully compiler assigns to a register.
int i = 0;
if (capacity & 3 == 0)
{  
    for (i = 0; i < capacity; i += 4)
    {
        id[i + 0] = fill_value;
        id[i + 1] = fill_value;
        id[i + 2] = fill_value;
        id[i + 3] = fill_value;
    }
}
// initialize remaining slots
for (; i < capacity; ++i)
{
    id[i] = 0;
}

The use of fill_value variable rather than as a constant in the loop is to suggest to the compiler of placing fill_value into a register. In many processors, writing a register to memory is more efficient than either writing a constant to memory or loading the constant to register, then writing to memory (during the loop).

The idea of unrolling the loop is execute more data instructions in a row before the jump or branch instruction. Processor's don't like branch instructions. Branch instructions cause the processor to decide to reload the instruction cache or not; this occupies time that could be spent executing data instructions. The unrolled loop is also performing less compares than the original loop. Again, compare instructions occupy time that could be spent executing data instructions.

No Looping

The goal is to minimize branching and comparing.
If your array is small (by your definition), you may want to assign the slots without a loop:

int * p = &id[0];
const int fill_value = 0;
*p++ = fill_value;  *p++ = fill_value; *p++ = fill_value; *p++ = fill_value;  
*p++ = fill_value;  *p++ = fill_value; *p++ = fill_value; *p++ = fill_value;  
*p++ = fill_value;  *p++ = fill_value; *p++ = fill_value; *p++ = fill_value;  
*p++ = fill_value;  *p++ = fill_value; *p++ = fill_value; *p++ = fill_value;  
*p++ = fill_value;  *p++ = fill_value; *p++ = fill_value; *p++ = fill_value;  

The operation of incrementing the pointer and deferencing is still faster than having the processor compare a value or change the program counter (branch).