Làm thế nào để khởi tạo tất cả các thành viên của một mảng thành cùng một giá trị?

Tôi có một mảng lớn trong C (không phải C ++ nếu điều đó tạo ra sự khác biệt). Tôi muốn khởi tạo tất cả các thành viên có cùng giá trị.

Tôi có thể thề rằng tôi đã từng biết một cách đơn giản để làm điều này. Tôi có thể sử dụng memset()trong trường hợp của mình, nhưng không có cách nào để làm điều này được tích hợp ngay trong cú pháp C?

Trừ khi giá trị đó là 0 (trong trường hợp đó bạn có thể bỏ qua một phần của trình khởi tạo và các phần tử tương ứng sẽ được khởi tạo thành 0), không có cách nào dễ dàng.

Đừng bỏ qua giải pháp rõ ràng:

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

Các phần tử có giá trị bị thiếu sẽ được khởi tạo thành 0:

int myArray[10] = { 1, 2 }; // initialize to 1,2,0,0,0...

Vì vậy, điều này sẽ khởi tạo tất cả các yếu tố thành 0:

int myArray[10] = { 0 }; // all elements 0

Trong C ++, một danh sách khởi tạo trống cũng sẽ khởi tạo mọi phần tử thành 0. Điều này không được phép với C:

int myArray[10] = {}; // all elements 0 in C++

Hãy nhớ rằng các đối tượng có thời lượng lưu trữ tĩnh sẽ khởi tạo thành 0 nếu không có trình khởi tạo nào được chỉ định:

static int myArray[10]; // all elements 0

Và "0" không nhất thiết có nghĩa là "all-bits-zero", vì vậy sử dụng cách trên là tốt hơn và dễ mang theo hơn bộ nhớ (). (Giá trị điểm nổi sẽ được khởi tạo thành +0, con trỏ thành giá trị null, v.v.)

Nếu trình biên dịch của bạn là GCC, bạn có thể sử dụng cú pháp sau:

int array[1024] = {[0 ... 1023] = 5};

Kiểm tra mô tả chi tiết: http://gcc.gnu.org/onlinesocs/gcc-4.1.2/gcc/Designated-Inits.html

Để khởi tạo tĩnh một mảng lớn có cùng giá trị, không có nhiều bản sao-dán, bạn có thể sử dụng macro:

#define VAL_1X     42
#define VAL_2X     VAL_1X,  VAL_1X
#define VAL_4X     VAL_2X,  VAL_2X
#define VAL_8X     VAL_4X,  VAL_4X
#define VAL_16X    VAL_8X,  VAL_8X
#define VAL_32X    VAL_16X, VAL_16X
#define VAL_64X    VAL_32X, VAL_32X

int myArray[53] = { VAL_32X, VAL_16X, VAL_4X, VAL_1X };

Nếu bạn cần thay đổi giá trị, bạn phải thay thế tại một nơi duy nhất.

Chỉnh sửa: các tiện ích mở rộng hữu ích có thể

(lịch sự của Jonathan Leffler )

Bạn có thể dễ dàng khái quát hóa điều này với:

#define VAL_1(X) X
#define VAL_2(X) VAL_1(X), VAL_1(X)
/* etc. */

Một biến thể có thể được tạo bằng cách sử dụng:

#define STRUCTVAL_1(...) { __VA_ARGS__ }
#define STRUCTVAL_2(...) STRUCTVAL_1(__VA_ARGS__), STRUCTVAL_1(__VA_ARGS__)
/*etc */ 

mà làm việc với các cấu trúc hoặc mảng ghép.

#define STRUCTVAL_48(...) STRUCTVAL_32(__VA_ARGS__), STRUCTVAL_16(__VA_ARGS__)

struct Pair { char key[16]; char val[32]; };
struct Pair p_data[] = { STRUCTVAL_48("Key", "Value") };
int a_data[][4] = { STRUCTVAL_48(12, 19, 23, 37) };

tên vĩ mô có thể thương lượng.

Nếu bạn muốn đảm bảo rằng mọi thành viên của mảng được khởi tạo rõ ràng, chỉ cần bỏ qua thứ nguyên từ khai báo:

int myArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

Trình biên dịch sẽ suy ra kích thước từ danh sách khởi tạo. Thật không may, đối với các mảng nhiều chiều, chỉ có thể bỏ qua kích thước ngoài cùng:

int myPoints[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

không sao, nhưng

int myPoints[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

không phải.

Tôi thấy một số mã sử dụng cú pháp này:

char* array[] = 
{
    [0] = "Hello",
    [1] = "World"
};   

Nơi nó trở nên đặc biệt hữu ích là nếu bạn tạo một mảng sử dụng enums làm chỉ mục:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

#define _ITEM(x) [x] = #x

char* array[] = 
{
    _ITEM(ERR_OK),
    _ITEM(ERR_FAIL),
    _ITEM(ERR_MEMORY)
};   

Điều này giữ mọi thứ theo thứ tự, ngay cả khi bạn tình cờ viết một số giá trị enum ngoài trật tự.

Thông tin thêm về kỹ thuật này có thể được tìm thấy ở đây và ở đây .

int i;
for (i = 0; i < ARRAY_SIZE; ++i)
{
  myArray[i] = VALUE;
}

Tôi nghĩ rằng điều này là tốt hơn

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5...

kích thước của các thay đổi mảng.

Bạn có thể thực hiện toàn bộ điều khởi tạo tĩnh như chi tiết ở trên, nhưng nó có thể là một người lập dị thực sự khi kích thước mảng của bạn thay đổi (khi mảng của bạn khởi động, nếu bạn không thêm trình khởi tạo bổ sung thích hợp, bạn sẽ nhận được rác).

memset cung cấp cho bạn một lần truy cập thời gian chạy để thực hiện công việc, nhưng không có kích thước mã nào được thực hiện đúng là miễn dịch với thay đổi kích thước mảng. Tôi sẽ sử dụng giải pháp này trong gần như tất cả các trường hợp khi mảng lớn hơn, giả sử, vài chục phần tử.

Nếu điều thực sự quan trọng là mảng được khai báo tĩnh, tôi sẽ viết chương trình viết chương trình cho tôi và biến nó thành một phần của quá trình xây dựng.

Đây là một cách khác:

static void
unhandled_interrupt(struct trap_frame *frame, int irq, void *arg)
{
    //this code intentionally left blank
}

static struct irqtbl_s vector_tbl[XCHAL_NUM_INTERRUPTS] = {
    [0 ... XCHAL_NUM_INTERRUPTS-1] {unhandled_interrupt, NULL},
};

Xem:

Phần mở rộng C

Chỉ định inits

Sau đó đặt câu hỏi: Khi nào người ta có thể sử dụng tiện ích mở rộng C?

Mẫu mã ở trên nằm trong một hệ thống nhúng và sẽ không bao giờ nhìn thấy ánh sáng từ trình biên dịch khác.

Để khởi tạo các kiểu dữ liệu 'bình thường' (như mảng int), bạn có thể sử dụng ký hiệu dấu ngoặc, nhưng nó sẽ bằng 0 các giá trị sau lần cuối nếu vẫn còn khoảng trống trong mảng:

// put values 1-8, then two zeroes
int list[10] = {1,2,3,4,5,6,7,8};

Nếu mảng xảy ra là int hoặc bất cứ thứ gì có kích thước int hoặc kích thước mô hình mem của bạn khớp với thời gian chính xác vào một int (tức là tất cả các số 0 hoặc 0xA5A5A5A5), cách tốt nhất là sử dụng memset () .

Nếu không, hãy gọi memcpy () trong một vòng lặp di chuyển chỉ mục.

Một câu trả lời hơi khóe miệng; viết tuyên bố

array = initial_value

trong ngôn ngữ có khả năng mảng yêu thích của bạn (của tôi là Fortran, nhưng có nhiều ngôn ngữ khác) và liên kết nó với mã C của bạn. Bạn có thể muốn bọc nó thành một chức năng bên ngoài.

Có một cách nhanh chóng để khởi tạo mảng của bất kỳ loại nào với giá trị đã cho. Nó hoạt động rất tốt với các mảng lớn. Thuật toán như sau:

• khởi tạo phần tử đầu tiên của mảng (cách thông thường)
• phần sao chép đã được đặt thành phần chưa được đặt, nhân đôi kích thước với mỗi thao tác sao chép tiếp theo

Đối với mảng 1 000 000phần tử, intnó nhanh hơn 4 lần so với khởi tạo vòng lặp thông thường (i5, 2 lõi, 2,3 GHz, bộ nhớ 4GiB, 64 bit):

loop runtime 0.004248 [seconds]

memfill() runtime 0.001085 [seconds]

#include <stdio.h>
#include <time.h>
#include <string.h>
#define ARR_SIZE 1000000

void memfill(void *dest, size_t destsize, size_t elemsize) {
   char   *nextdest = (char *) dest + elemsize;
   size_t movesize, donesize = elemsize;

   destsize -= elemsize;
   while (destsize) {
      movesize = (donesize < destsize) ? donesize : destsize;
      memcpy(nextdest, dest, movesize);
      nextdest += movesize; destsize -= movesize; donesize += movesize;
   }
}    
int main() {
    clock_t timeStart;
    double  runTime;
    int     i, a[ARR_SIZE];

    timeStart = clock();
    for (i = 0; i < ARR_SIZE; i++)
        a[i] = 9;    
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("loop runtime %f [seconds]\n",runTime);

    timeStart = clock();
    a[0] = 10;
    memfill(a, sizeof(a), sizeof(a[0]));
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("memfill() runtime %f [seconds]\n",runTime);
    return 0;
}

Không ai đã đề cập đến thứ tự chỉ mục để truy cập các phần tử của mảng khởi tạo. Mã ví dụ của tôi sẽ đưa ra một ví dụ minh họa cho nó.

#include <iostream>

void PrintArray(int a[3][3])
{
    std::cout << "a11 = " << a[0][0] << "\t\t" << "a12 = " << a[0][1] << "\t\t" << "a13 = " << a[0][2] << std::endl;
    std::cout << "a21 = " << a[1][0] << "\t\t" << "a22 = " << a[1][1] << "\t\t" << "a23 = " << a[1][2] << std::endl;
    std::cout << "a31 = " << a[2][0] << "\t\t" << "a32 = " << a[2][1] << "\t\t" << "a33 = " << a[2][2] << std::endl;
    std::cout << std::endl;
}

int wmain(int argc, wchar_t * argv[])
{
    int a1[3][3] =  {   11,     12,     13,     // The most
                        21,     22,     23,     // basic
                        31,     32,     33  };  // format.

    int a2[][3] =   {   11,     12,     13,     // The first (outer) dimension
                        21,     22,     23,     // may be omitted. The compiler
                        31,     32,     33  };  // will automatically deduce it.

    int a3[3][3] =  {   {11,    12,     13},    // The elements of each
                        {21,    22,     23},    // second (inner) dimension
                        {31,    32,     33} };  // can be grouped together.

    int a4[][3] =   {   {11,    12,     13},    // Again, the first dimension
                        {21,    22,     23},    // can be omitted when the 
                        {31,    32,     33} };  // inner elements are grouped.

    PrintArray(a1);
    PrintArray(a2);
    PrintArray(a3);
    PrintArray(a4);

    // This part shows in which order the elements are stored in the memory.
    int * b = (int *) a1;   // The output is the same for the all four arrays.
    for (int i=0; i<9; i++)
    {
        std::cout << b[i] << '\t';
    }

    return 0;
}

Đầu ra là:

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

11      12      13      21      22      23      31      32      33

Bỏ qua tất cả các cuộc trò chuyện, câu trả lời ngắn gọn là nếu bạn bật tối ưu hóa vào thời gian biên dịch, bạn sẽ không làm tốt hơn thế này:

int i,value=5,array[1000]; 
for(i=0;i<1000;i++) array[i]=value; 

Đã thêm tiền thưởng: mã thực sự dễ đọc :)

1. Nếu mảng của bạn được khai báo là tĩnh hoặc là toàn cục, tất cả các phần tử trong mảng đã có giá trị mặc định 0.
2. Một số trình biên dịch đặt mảng mặc định thành 0 trong chế độ gỡ lỗi.
3. Thật dễ dàng để đặt mặc định thành 0: int mảng [10] = {0};
4. Tuy nhiên, đối với các giá trị khác, bạn đã sử dụng vòng lặp memset () hoặc vòng lặp;

ví dụ: mảng int [10]; bộ nhớ (mảng, -1, 10 * sizeof (int));

#include<stdio.h>
int main(){
int i,a[50];
for (i=0;i<50;i++){
    a[i]=5;// set value 5 to all the array index
}
for (i=0;i<50;i++)
printf("%d\n",a[i]);
   return 0;
}

Nó sẽ cung cấp cho o / p 5 5 5 5 5 5 ...... cho đến khi kích thước của toàn bộ mảng

Tôi biết rằng người dùng đã Tarskitrả lời câu hỏi này theo cách tương tự, nhưng tôi đã thêm một vài chi tiết. Hãy tha thứ cho một số C của tôi vì tôi hơi khó chịu vì tôi có xu hướng muốn sử dụng C ++ hơn, nhưng rồi đây.

Nếu bạn biết kích thước của mảng trước thời hạn ...

#include <stdio.h>

typedef const unsigned int cUINT;
typedef unsigned int UINT;

cUINT size = 10;
cUINT initVal = 5;

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal );
void printArray( UINT* myArray ); 

int main() {        
    UINT myArray[size]; 
    /* Not initialized during declaration but can be
    initialized using a function for the appropriate TYPE*/
    arrayInitializer( myArray, size, initVal );

    printArray( myArray );

    return 0;
}

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal ) {
    for ( UINT n = 0; n < size; n++ ) {
        myArray[n] = initVal;
    }
}

void printArray( UINT* myArray ) {
    printf( "myArray = { " );
    for ( UINT n = 0; n < size; n++ ) {
        printf( "%u", myArray[n] );

        if ( n < size-1 )
            printf( ", " );
    }
    printf( " }\n" );
}

Có một vài cảnh báo ở trên; một là UINT myArray[size];không được khởi tạo trực tiếp khi khai báo, tuy nhiên khối mã hoặc lệnh gọi hàm tiếp theo sẽ khởi tạo từng phần tử của mảng thành cùng một giá trị bạn muốn. Nhắc nhở khác là, bạn sẽ phải viết một initializing functioncho mỗi typebạn sẽ hỗ trợ và bạn cũng sẽ phải sửa đổi printArray()chức năng để hỗ trợ các loại đó.

Bạn có thể thử mã này với một trình biên dịch trực tuyến được tìm thấy ở đây .

Đối với khởi tạo chậm (nghĩa là khởi tạo hàm tạo thành viên lớp), hãy xem xét:

int a[4];

unsigned int size = sizeof(a) / sizeof(a[0]);
for (unsigned int i = 0; i < size; i++)
  a[i] = 0;

Tôi biết câu hỏi ban đầu rõ ràng đề cập đến C và không phải C ++, nhưng nếu bạn (như tôi) đến đây để tìm giải pháp cho mảng C ++, thì đây là một mẹo nhỏ:

Nếu trình biên dịch của bạn hỗ trợ các biểu thức gấp , bạn có thể sử dụng ma thuật mẫu và std::index_sequenceđể tạo danh sách trình khởi tạo với giá trị mà bạn muốn. Và bạn thậm chí có thể làm constexprđiều đó và cảm thấy như một ông chủ:

#include <array>

/// [3]
/// This functions's only purpose is to ignore the index given as the second
/// template argument and to always produce the value passed in.
template<class T, size_t /*ignored*/>
constexpr T identity_func(const T& value) {
    return value;
}

/// [2]
/// At this point, we have a list of indices that we can unfold
/// into an initializer list using the `identity_func` above.
template<class T, size_t... Indices>
constexpr std::array<T, sizeof...(Indices)>
make_array_of_impl(const T& value, std::index_sequence<Indices...>) {
    return {identity_func<T, Indices>(value)...};
}

/// [1]
/// This is the user-facing function.
/// The template arguments are swapped compared to the order used
/// for std::array, this way we can let the compiler infer the type
/// from the given value but still define it explicitly if we want to.
template<size_t Size, class T>
constexpr std::array<T, Size> 
make_array_of(const T& value) {
    using Indices = std::make_index_sequence<Size>;
    return make_array_of_impl(value, Indices{});
}

// std::array<int, 4>{42, 42, 42, 42}
constexpr auto test_array = make_array_of<4/*, int*/>(42);
static_assert(test_array[0] == 42);
static_assert(test_array[1] == 42);
static_assert(test_array[2] == 42);
static_assert(test_array[3] == 42);
// static_assert(test_array[4] == 42); out of bounds

Bạn có thể xem mã tại nơi làm việc (tại Wandbox)

Tôi thấy không có yêu cầu nào trong câu hỏi, vì vậy giải pháp phải chung chung: khởi tạo một mảng đa chiều có thể không xác định được xây dựng từ các thành phần cấu trúc có thể không xác định với giá trị thành viên ban đầu:

#include <string.h> 

void array_init( void *start, size_t element_size, size_t elements, void *initval ){
  memcpy(        start,              initval, element_size              );
  memcpy( (char*)start+element_size, start,   element_size*(elements-1) );
}

// testing
#include <stdio.h> 

struct s {
  int a;
  char b;
} array[2][3], init;

int main(){
  init = (struct s){.a = 3, .b = 'x'};
  array_init( array, sizeof(array[0][0]), 2*3, &init );

  for( int i=0; i<2; i++ )
    for( int j=0; j<3; j++ )
      printf("array[%i][%i].a = %i .b = '%c'\n",i,j,array[i][j].a,array[i][j].b);
}

Kết quả:

array[0][0].a = 3 .b = 'x'
array[0][1].a = 3 .b = 'x'
array[0][2].a = 3 .b = 'x'
array[1][0].a = 3 .b = 'x'
array[1][1].a = 3 .b = 'x'
array[1][2].a = 3 .b = 'x'

EDIT: start+element_sizeđã đổi thành(char*)start+element_size

Trước đây (và tôi không nói đó là một ý tưởng hay), chúng tôi đã thiết lập yếu tố đầu tiên và sau đó:

memcpy (&element [1], &element [0], sizeof (element)-sizeof (element [0]);

Thậm chí không chắc chắn nó sẽ hoạt động nữa (điều đó phụ thuộc vào việc triển khai memcpy) nhưng nó hoạt động bằng cách sao chép liên tục phần tử ban đầu sang phần tiếp theo - thậm chí hoạt động cho các mảng cấu trúc.

Nếu bạn có nghĩa là song song, tôi nghĩ toán tử dấu phẩy khi được sử dụng cùng với một biểu thức có thể làm điều đó:

a[1]=1, a[2]=2, ..., a[indexSize]; 

hoặc nếu bạn có nghĩa là trong một cấu trúc đơn lẻ, bạn có thể làm điều đó trong một vòng lặp for:

for(int index = 0, value = 10; index < sizeof(array)/sizeof(array[0]); index++, value--)
  array[index] = index;

// Lưu ý toán tử dấu phẩy trong danh sách đối số không phải là toán tử song song được mô tả ở trên;

Bạn có thể khởi tạo một bộ giải mã mảng:

array[] = {1, 2, 3, 4, 5};

Bạn có thể thực hiện cuộc gọi đến malloc / calloc / sbrk / alloca / etc để phân bổ một vùng lưu trữ cố định cho một đối tượng:

int *array = malloc(sizeof(int)*numberOfListElements/Indexes);

và truy cập các thành viên bằng cách:

*(array + index)

Vân vân.