what is array in c in hindi




एक सरणी के सभी सदस्यों को एक ही मूल्य में कैसे प्रारंभ करें? (13)

मेरे पास सी में एक बड़ी सरणी है (सी ++ नहीं अगर इससे कोई फर्क पड़ता है)। मैं सभी सदस्यों को एक ही मूल्य में शुरू करना चाहता हूं। मैं कसम खाता हूं कि मुझे ऐसा करने का एक आसान तरीका पता था। मैं अपने मामले में memset() उपयोग कर सकता हूं, लेकिन ऐसा करने का कोई तरीका नहीं है जो सी सिंटैक्स में बनाया गया है?


  1. यदि आपकी सरणी स्थिर या वैश्विक है, तो सरणी के सभी तत्वों में पहले से ही डिफ़ॉल्ट डिफ़ॉल्ट मान 0 है।
  2. कुछ कंपाइलर्स डीबग मोड में सरणी को 0 से डिफ़ॉल्ट सेट करते हैं।
  3. डिफ़ॉल्ट को 0: int सरणी सेट करना आसान है [10] = {0};
  4. हालांकि, अन्य मानों के लिए, आपने memset () या लूप का उपयोग किया है;

उदाहरण: int सरणी [10]; स्मृति (सरणी, -1, 10 * आकार (int));


'सामान्य' डेटा प्रकारों (जैसे int arrays) को प्रारंभ करने के लिए, आप ब्रैकेट नोटेशन का उपयोग कर सकते हैं, लेकिन यदि सरणी में अभी भी स्थान है तो यह अंतिम के बाद मानों को शून्य करेगा:

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

आप मेमसेट फ़ंक्शन का उपयोग कर सकते हैं।

void *memset(void *array, int value, unsigned sizeofarray);

एक ही मूल्य के साथ एक बड़ी सरणी को स्थिर रूप से प्रारंभ करने के लिए, एकाधिक प्रति-पेस्ट के बिना, आप मैक्रोज़ का उपयोग कर सकते हैं:

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

मैक्रो नाम परक्राम्य हैं।


थोड़ा जीभ-इन-गाल जवाब; बयान लिखें

array = initial_value

आपकी पसंदीदा सरणी-सक्षम भाषा में (मेरा फोरट्रान है, लेकिन कई अन्य हैं), और इसे अपने सी कोड से लिंक करें। आप शायद इसे एक बाहरी समारोह के रूप में लपेटना चाहते हैं।


दिए गए मान के साथ किसी भी प्रकार की सरणी शुरू करने का एक तेज़ तरीका है। यह बड़े सरणी के साथ बहुत अच्छी तरह से काम करता है। एल्गोरिदम निम्नानुसार है:

  • सरणी के पहले तत्व को प्रारंभ करें (सामान्य तरीका)
  • भाग को कॉपी करें जिसे भाग में सेट किया गया है जो सेट नहीं किया गया है, प्रत्येक अगली प्रतिलिपि ऑपरेशन के साथ आकार को दोगुना कर दिया गया है

1 000 000 तत्व int सरणी के लिए यह नियमित लूप प्रारंभिक (i5, 2 कोर, 2.3 गीगा, 4 जीआईबी मेमोरी, 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;
}

मुझे पता है कि उपयोगकर्ता Tarski ने इस सवाल का जवाब उसी तरह से दिया, लेकिन मैंने कुछ और विवरण जोड़े। मेरे कुछ सी को क्षमा करें क्योंकि मैं थोड़ा सा जंगली हूं क्योंकि मैं सी ++ का उपयोग करना चाहता हूं, लेकिन यहां यह जाता है।

यदि आप समय से पहले सरणी का आकार जानते हैं ...

#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]; घोषणा पर सीधे शुरू नहीं किया गया है, हालांकि अगली कोड ब्लॉक या फ़ंक्शन कॉल सरणी के प्रत्येक तत्व को उसी वैल्यू में प्रारंभ करता है जो आप चाहते हैं। दूसरी चेतावनी है, आपको प्रत्येक type समर्थन के लिए initializing function लिखना होगा और आपको उन प्रकारों का समर्थन करने के लिए printArray() फ़ंक्शन को भी संशोधित करना होगा।

आप इस कोड को here ऑनलाइन अनुयायी के साथ आजमा सकते here


मुझे प्रश्न में कोई आवश्यकता नहीं दिखती है, इसलिए समाधान सामान्य होना चाहिए: प्रारंभिक सदस्य मूल्य के साथ अनिर्दिष्ट संभवतः संरचना तत्वों से निर्मित एक अनिर्दिष्ट संभव बहुआयामी सरणी का प्रारंभिकरण:

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

परिणाम:

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


यदि आप यह सुनिश्चित करना चाहते हैं कि सरणी के प्रत्येक सदस्य को स्पष्ट रूप से प्रारंभ किया गया है, तो घोषणा से आयाम को छोड़ दें:

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

नहीं है।


यदि आपका कंपाइलर जीसीसी है तो आप निम्न वाक्यविन्यास का उपयोग कर सकते हैं:

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

विस्तृत विवरण देखें: http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html


यहां एक और तरीका है:

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

देख:

C-Extensions

नामित inits

फिर सवाल पूछें: सी एक्सटेंशन का उपयोग कब कर सकता है?

उपरोक्त कोड नमूना एक एम्बेडेड सिस्टम में है और कभी भी किसी अन्य कंपाइलर से प्रकाश नहीं देखेगा।


सभी चापलूसी के माध्यम से काटना, संक्षिप्त जवाब यह है कि यदि आप संकलन समय पर अनुकूलन चालू करते हैं तो आप इससे बेहतर नहीं करेंगे:

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

जोड़ा बोनस: कोड वास्तव में सुपाठ्य है :)


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...

सरणी परिवर्तन के आकार को शामिल करें।






array-initialize