අරාවෙහි සියලුම සාමාජිකයන් එකම අගයකට ආරම්භ කරන්නේ කෙසේද?

මට C හි විශාල අරාවක් ඇත ( එය වෙනසක් කරන්නේ නම් C ++ නොවේ ). එකම වටිනාකමක් ඇති සියලුම සාමාජිකයින් ආරම්භ කිරීමට මට අවශ්‍යය.

මට දිවුරන්න පුළුවන් මම වරක් මෙය කිරීමට සරල ක්‍රමයක් දැන සිටි බව. memset()මගේ නඩුවේදී මට භාවිතා කළ හැකිය , නමුත් සී සින්ටැක්ස් තුළම ගොඩනගා ඇති මෙය කිරීමට ක්‍රමයක් නැද්ද?

එම අගය 0 නොවේ නම් (ඔබට ආරම්භකයේ යම් කොටසක් අතහැර දැමිය හැකි අතර අනුරූප මූලද්‍රව්‍ය 0 දක්වා ආරම්භ වේ), පහසු ක්‍රමයක් නොමැත.

නමුත් පැහැදිලි විසඳුම නොසලකා හරින්න.

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

නැතිවූ අගයන් සහිත මූලද්‍රව්‍ය 0 ට ආරම්භ කෙරේ:

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

එබැවින් මෙය සියලුම අංග 0 ට ආරම්භ කරයි:

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

C ++ හි, හිස් ආරම්භක ලැයිස්තුවක් මඟින් සෑම අංගයක්ම 0 දක්වා ආරම්භ කරනු ඇත. මෙය C සමඟ අවසර නැත :

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

ආරම්භකය නිශ්චිතව දක්වා නොමැති නම් ස්ථිතික ගබඩා කාල සීමාවක් ඇති වස්තු 0 දක්වා ආරම්භ වන බව මතක තබා ගන්න:

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

“0” යන්නෙහි අර්ථය “සියලු බිටු-ශුන්‍යය” යන්න නොවේ, එබැවින් ඉහත භාවිතා කිරීම මෙම්සෙට් () ට වඩා හොඳ සහ අතේ ගෙන යා හැකි ය. (පාවෙන ලක්ෂ්‍ය අගයන් +0 ට ද, දර්ශක ශුන්‍ය අගයට ද ආරම්භ කෙරේ.)

ඔබේ සම්පාදකයා ජීසීසී නම් ඔබට පහත සින්ටැක්ස් භාවිතා කළ හැකිය:

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

සවිස්තරාත්මක විස්තරය බලන්න: http://gcc.gnu.org/onlineocs/gcc-4.1.2/gcc/Designated-Inits.html

බහු පිටපත්-පේස්ට් නොමැතිව එකම අගයක් සහිත විශාල අරාවක් ස්ථිතිකව ආරම්භ කිරීම සඳහා, ඔබට මැක්‍රෝස් භාවිතා කළ හැකිය:

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

ඔබට අගය වෙනස් කිරීමට අවශ්‍ය නම්, ප්‍රතිස්ථාපනය කළ යුත්තේ එක් ස්ථානයක පමණි.

සංස්කරණය කරන්න: හැකි ප්‍රයෝජනවත් දිගු

(අනුග්‍රහය ජොනතන් ලෙෆ්ලර් )

ඔබට මෙය පහසුවෙන් සාමාන්‍යකරණය කළ හැකිය:

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

මෙය භාවිතයෙන් ප්‍රභේදයක් නිර්මාණය කළ හැකිය:

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

එය ව්‍යුහයන් හෝ සංයුක්ත අරා සමඟ ක්‍රියා කරයි.

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

සාර්ව නම් හුවමාරු කර ගත හැකිය.

අරාවෙහි සෑම සාමාජිකයෙකුම පැහැදිලිවම ආරම්භ කර ඇති බව සහතික කිරීමට ඔබට අවශ්‍ය නම්, ප්‍රකාශයේ මානය අතහරින්න:

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

සම්පාදකයා ආරම්භක ලැයිස්තුවෙන් මානය අඩු කරයි. අවාසනාවකට මෙන්, බහුමානීය අරා සඳහා පිටත මානය පමණක් ඉවත් කළ හැකිය:

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

හරි, නමුත්

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

නැත.

මෙම සින්ටැක්ස් භාවිතා කරන කේත කිහිපයක් මම දුටුවෙමි:

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

එය විශේෂයෙන් ප්‍රයෝජනවත් වන්නේ කොතැනද යන්න නම්, ඔබ දර්ශකය ලෙස enums භාවිතා කරන අරාවක් සාදන්නේ නම්:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

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

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

ඔබ සමහර එන්-අගයන් පිළිවෙලට ලිවීමට සිදුවුවද, මෙය දේවල් පිළිවෙලට තබා ගනී.

මෙම තාක්ෂණය පිළිබඳ වැඩි විස්තර මෙතැනින් සහ මෙතැනින් සොයාගත හැකිය .

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

මම හිතන්නේ මේකට වඩා හොඳයි

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

අරාවෙහි විශාලත්වය වෙනස් කරන්න.

ඉහත විස්තර කර ඇති පරිදි ඔබට සම්පූර්ණ ස්ථිතික ආරම්භක දේ කළ හැකිය, නමුත් ඔබේ අරාවෙහි ප්‍රමාණය වෙනස් වන විට එය සැබෑ බමරයක් විය හැකිය (ඔබේ අරාව එම්බිජෙන් කරන විට, ඔබ සුදුසු අතිරේක ආරම්භක එකතු නොකරන්නේ නම් ඔබට කුණු ලැබේ).

memset මඟින් ඔබට වැඩ කිරීම සඳහා ධාවන කාල පහරක් ලබා දෙයි, නමුත් නිවැරදිව සිදු කරන ලද කේත ප්‍රමාණයේ කිසිදු පහරක් අරාව ප්‍රමාණයේ වෙනස්වීම් වලින් නිදහස් නොවේ. අරාව මූලද්‍රව්‍ය දුසිම් කිහිපයකට වඩා විශාල වූ විට මම සෑම අවස්ථාවකම පාහේ මෙම විසඳුම භාවිතා කරමි.

අරාව ස්ථිතිකව ප්‍රකාශයට පත් කිරීම ඇත්තෙන්ම වැදගත් නම්, මා වෙනුවෙන් වැඩසටහන ලිවීමට හා එය ගොඩ නැගීමේ ක්‍රියාවලියේ කොටසක් බවට පත් කිරීමට මම වැඩසටහනක් ලියමි.

මෙන්න තවත් ක්‍රමයක්:

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

බලන්න:

සී දිගු

නම් කරන ලද inits

ඉන්පසු ප්‍රශ්නය අසන්න: කෙනෙකුට සී දිගු භාවිතා කළ හැක්කේ කවදාද?

ඉහත කේත නියැදිය කාවැද්දූ පද්ධතියක ඇති අතර වෙනත් සම්පාදකයෙකුගේ ආලෝකය කිසි විටෙකත් නොපෙනේ.

'සාමාන්‍ය' දත්ත වර්ග ආරම්භ කිරීම සඳහා (int අරා වැනි), ඔබට වරහන් අංකනය භාවිතා කළ හැකිය, නමුත් අරාවෙහි තවමත් ඉඩ තිබේ නම් එය අවසාන අගයෙන් පසු ශුන්‍ය වනු ඇත:

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

අරාව int හෝ විශාලත්වයකින් යුක්ත නම් හෝ ඔබේ මතක රටාවේ ප්‍රමාණය හරියටම වේලාවට int ට ගැලපේ නම් (එනම් සියලුම ශුන්‍ය හෝ 0xA5A5A5A5), හොඳම ක්‍රමය වන්නේ memset () .

එසේ නොමැතිනම් දර්ශකය චලනය වන ලූපයක memcpy () අමතන්න.

කම්මුලට මඳක් පිළිතුර; ප්රකාශය ලියන්න

array = initial_value

ඔබගේ ප්‍රියතම අරාව-හැකියාව ඇති භාෂාවෙන් (මගේ ෆෝට්රාන්, නමුත් තවත් බොහෝ දේ ඇත), එය ඔබේ සී කේතයට සම්බන්ධ කරන්න. ඔබට එය බාහිර ශ්‍රිතයක් ලෙස ඔතා ගැනීමට අවශ්‍ය වනු ඇත.

දී ඇති අගය සහිත ඕනෑම වර්ගයක අරාව ආරම්භ කිරීමට වේගවත් ක්‍රමයක් තිබේ. එය විශාල අරා සමඟ ඉතා හොඳින් ක්රියා කරයි. ඇල්ගොරිතම පහත පරිදි වේ:

• අරාවේ පළමු අංගය ආරම්භ කරන්න (සුපුරුදු ක්‍රමය)
• පිටපත් කරන ලද කොටස සකසා නොමැති කොටසකට සකසා ඇති අතර, එක් එක් ඊළඟ පිටපත් කිරීමේ ක්‍රියාවලිය සමඟ ප්‍රමාණය දෙගුණ කරයි

සඳහා 1 000 000අංග intරැසක් එය නිත්ය පුඩුවක් ආරම්භය (i5, 2 මධ්යය, 2.3 GHz, 4GiB මතකය, 64 බිට්) ට වඩා 4 ගුණයක් වේගවත් වේ:

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

ආරම්භක අරාවෙහි මූලද්‍රව්‍යයන්ට ප්‍රවේශ වීම සඳහා දර්ශක අනුපිළිවෙල කිසිවෙකු සඳහන් කර නැත. මගේ උදාහරණ කේතය එයට නිදර්ශන උදාහරණයක් ලබා දෙනු ඇත.

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

ප්‍රතිදානය:

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

1. ඔබගේ අරාව ස්ථිතික ලෙස ප්‍රකාශයට පත් කර ඇත්නම් හෝ ගෝලීය නම්, අරාවෙහි ඇති සියලුම අංගවල පෙරනිමි පෙරනිමි අගය 0 ඇත.
2. සමහර සම්පාදකයින් විසින් අරාවෙහි පෙරනිමිය 0 ලෙස නිදොස් කිරීමේ ප්‍රකාරයේදී සකසයි.
3. පෙරනිමිය 0 ලෙස සැකසීම පහසුය: int array [10] = {0};
4. කෙසේ වෙතත්, වෙනත් අගයන් සඳහා, ඔබට මෙම්සෙට් () හෝ ලූප් භාවිතා කර ඇත;

උදාහරණය: int array [10]; memset (අරාව, -1, 10 * ප්‍රමාණය (int));

සියලු කතාබහ කපා හරිමින්, කෙටි පිළිතුර නම්, ඔබ සම්පාදනය කරන වේලාවේදී ප්‍රශස්තිකරණය සක්‍රිය කළහොත් ඔබ මීට වඩා හොඳ දෙයක් නොකරනු ඇත:

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

ප්‍රසාද දීමනාව: කේතය ඇත්ත වශයෙන්ම පැහැදිලි ය :)

මුල් ප්‍රශ්නයේ C ගැන නොව C ++ ගැන පැහැදිලිවම සඳහන් වන බව මම දනිමි, නමුත් ඔබ (මා වැනි) මෙහි පැමිණියේ C ++ අරා සඳහා විසඳුමක් සොයමින් නම්, මෙන්න ඉතා හොඳ උපක්‍රමයක්:

ඔබේ සම්පාදකයා ගුණයකින් යුත් ප්‍රකාශන සඳහා සහය දක්වන්නේ නම් , ඔබට අච්චු මැජික් භාවිතා කළ හැකි std::index_sequenceඅතර ඔබට අවශ්‍ය අගය සමඟ ආරම්භක ලැයිස්තුවක් ජනනය කළ හැකිය. ඔබට එය පවා කළ හැකි constexprඅතර ලොක්කා මෙන් දැනිය හැකිය:

#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

ඔබට වැඩ කරන කේතය දෙස බැලිය හැකිය (වැන්ඩ්බොක්ස් හි)

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

එය සම්පූර්ණ අරාවෙහි ප්‍රමාණය දක්වා o / p 5 5 5 5 5 5 ...... ලබා දෙනු ඇත

පරිශීලකයා Tarskiමෙම ප්‍රශ්නයට සමාන ආකාරයකින් පිළිතුරු දුන් බව මම දනිමි , නමුත් මම තවත් විස්තර කිහිපයක් එකතු කළෙමි. C ++ භාවිතා කිරීමට මා වැඩි කැමැත්තක් දක්වන බැවින් මගේ C ට සමාව දෙන්න.

වේලාවට පෙර අරාවේ ප්‍රමාණය ඔබ දන්නේ නම් ...

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

ඉහත අවවාද කිහිපයක් තිබේ; එකක් නම් UINT myArray[size];ප්‍රකාශය මත කෙලින්ම ආරම්භ නොකෙරේ, කෙසේ වෙතත් ඊළඟ කේත වාරණය හෝ ක්‍රියාකාරී ඇමතුම මඟින් අරාවෙහි සෑම අංගයක්ම ඔබට අවශ්‍ය අගයටම ආරම්භ කරයි. අනෙක් අවවාදය නම්, ඔබ සහාය දක්වන initializing functionඑක් එක් සඳහා typeඔබට ලිවිය යුතු අතර printArray()එම වර්ග සඳහා සහය දැක්වීම සඳහා ශ්‍රිතය වෙනස් කිරීමටද ඔබට සිදුවේ .

ඔබට මෙහි ඇති සබැඳි සම්පාදකයෙකු සමඟ මෙම කේතය උත්සාහ කළ හැකිය .

ප්‍රමාද කිරීම සඳහා (එනම් පන්ති සාමාජික ඉදිකිරීම්කරු ආරම්භ කිරීම) සලකා බලන්න:

int a[4];

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

ප්‍රශ්නයේ කිසිදු අවශ්‍යතාවයක් මා දකින්නේ නැත, එබැවින් විසඳුම සාමාන්‍ය විය යුතුය: ආරම්භක සාමාජික අගයක් සහිත නිශ්චිතව දක්වා නොමැති ව්‍යුහමය අංග වලින් සාදන ලද නිශ්චිතව දක්වා නැති බහුමානීය අරාවක් ආරම්භ කිරීම:

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

ප්‍රති ult ලය:

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'

සංස්කරණය කරන්න: start+element_sizeවෙනස් කර ඇත(char*)start+element_size

ආපසු දවසේ (මම එය හොඳ අදහසක් යැයි නොකියමි), අපි පළමු අංගය සකසා පසුව:

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

එය තව දුරටත් ක්‍රියා කරනු ඇතැයි විශ්වාස නැත (එය memcpy ක්‍රියාත්මක කිරීම මත රඳා පවතී) නමුත් එය ක්‍රියාත්මක වන්නේ ආරම්භක මූලද්‍රව්‍යය ඊළඟට නැවත නැවත පිටපත් කිරීමෙනි - ව්‍යුහයන්ගේ අරා සඳහා පවා ක්‍රියා කරයි.

ඔබ සමාන්තරව අදහස් කරන්නේ නම්, කොමා ක්‍රියාකරුට ප්‍රකාශනයක් සමඟ භාවිතා කරන විට එය කළ හැකි යැයි මම සිතමි.

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

හෝ ඔබ අදහස් කරන්නේ තනි ඉදිකිරීමක් නම්, ඔබට එය ලූපයක් සඳහා කළ හැකිය:

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

// තර්ක ලැයිස්තුවේ කොමා ක්‍රියාකරු ඉහත විස්තර කර ඇති සමාන්තර ක්‍රියාකරු නොවන බව සලකන්න.

ඔබට අරාව ප්‍රකාශ කිරීම ආරම්භ කළ හැකිය:

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

වස්තුවකට ස්ථාවර ගබඩා කලාපයක් වෙන් කිරීම සඳහා ඔබට malloc / calloc / sbrk / alloca / etc වෙත ඇමතුමක් ලබා ගත හැකිය:

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

සහ සාමාජිකයින්ට ප්‍රවේශ විය හැක්කේ:

*(array + index)

ආදිය.