অ্যারের সমস্ত সদস্যকে কী একই মান হিসাবে শুরু করবেন?

968

আমার সিতে একটি বড় অ্যারে রয়েছে ( সি ++ যদি এটি কোনও পার্থক্য করে তবে)। আমি একই মানের সমস্ত সদস্যকে আরম্ভ করতে চাই।

আমি শপথ করতে পারি আমি একবার এটি করার একটি সহজ উপায় জানতাম। আমি memset()আমার ক্ষেত্রে ব্যবহার করতে পারি, তবে এটি করার কোনও উপায় নেই যা সি সিনট্যাক্সের মধ্যে নির্মিত হয়েছে?

c  arrays  initialization  array-initialize 
— ঔজ্বল্যহীন
সূত্র
16
এখন পর্যন্ত যে কোনও উত্তরে সি 99 এবং এর উপরে সম্ভাব্য যে মনোনীত ইনিশিয়ালাইজারের পরিচয় উল্লেখ করা হয়নি। উদাহরণস্বরূপ: enum { HYDROGEN = 1, HELIUM = 2, CARBON = 6, NEON = 10, … };এবং struct element { char name[15]; char symbol[3]; } elements[] = { [NEON] = { "Neon", "Ne" }, [HELIUM] = { "Helium", "He" }, [HYDROGEN] = { "Hydrogen", "H" }, [CARBON] = { "Carbon", "C" }, … };। আপনি যদি উপবৃত্ত সরিয়ে ফেলেন তবে …সেই টুকরাগুলি C99 বা C11 এর অধীনে সংকলন করে।
— জোনাথন লেফলার
আসলে আবলেঙ্কির উত্তর নির্ধারিত ইনিশিয়ালাইজার ব্যবহার করছে তবে পুরোপুরি আরম্ভের কোডটি তৈরি করা হয়নি
— রব 11311
মেমসেট () সাহায্য করতে পারে তবে মানের উপর নির্ভর করে।
— নিক
2
memset()নির্দিষ্ট আলোচনা: stackoverflow.com/questions/7202411/... আমি এটা শুধুমাত্র 0. জন্য কাজ করে মনে
— সিরো Santilli冠状病毒审查六四事件法轮功

উত্তর:

1238

যদি মান 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

সি ++ এ, একটি খালি সূচনা তালিকা প্রতিটি উপাদানকে 0-এ শুরু করে দেবে এটি সি দিয়ে অনুমোদিত নয় :

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

মনে রাখবেন যে স্ট্যাটিক স্টোরেজ সময়কাল সহ অবজেক্টগুলি 0 থেকে আরম্ভ হবে যদি কোনও প্রাথমিককরণ নির্দিষ্ট না করা থাকে:

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

এবং এটি "0" এর অর্থ অগত্যা "অল-বিটস-শূন্য" নয়, সুতরাং উপরেরটি ব্যবহার করা মেমসেট () এর চেয়ে ভাল এবং আরও বহনযোগ্য। (ভাসমান পয়েন্টের মানগুলি +0, নাল মান থেকে পয়েন্টার ইত্যাদিতে শুরু করা হবে)

— AIB
সূত্র
27
সি ++ স্ট্যান্ডার্ডের মাধ্যমে পড়া, আপনি ইনট অ্যারেও করতে পারেন [10] = {}; শূন্য সূচনা। আমার কাছে সি স্ট্যান্ডার্ড নেই যাচাই করার জন্য এটি বৈধ সি হিসাবে ভাল।
— workmad3
54
বিভাগের 7. at.৮ সন্ধান করে সি 99 স্ট্যান্ডার্ডের সূচনা, এটি খালি ইনিশিয়ালাইজার তালিকার অনুমতি দেওয়া হয়েছে বলে মনে হয় না।
— জোনাথন লেফলার
7
কাঠামো এবং অ্যারে প্রারম্ভিককরণের জন্য সি 99 এর অনেকগুলি দুর্দান্ত বৈশিষ্ট্য রয়েছে; এতে একটি বৈশিষ্ট্য নেই (তবে ফোর্টরান চতুর্থ, ১৯66,, ছিল) এটি অ্যারের জন্য একটি নির্দিষ্ট প্রাথমিকের পুনরাবৃত্তি করার একটি উপায়।
— জোনাথন লেফলার
8
@ সিটিনসার্ট: আপনি কী বোঝাতে চাইছেন যে এটি কাজ করে না? এই উত্তরটি যা করা উচিত ঠিক তা এটি করে। আপনার কোডে মন্তব্য যা বলে তা এটি করে না তবে মন্তব্যটি ভুল।
— বেনিয়ামিন লিন্ডলি
9
@ চ্যাটিনসার্ট: আপনিই একমাত্র দাবি করেছেন যে, এই মন্তব্যে, সমস্ত উপাদান -1 তে সেট করা হবে। এই উত্তরের দাবি, ঠিক আছে যে সমস্ত অনির্ধারিত উপাদান শূন্যে সেট হয়ে যায়। আপনার কোডের ফলাফলগুলি এই দাবির সাথে সামঞ্জস্যপূর্ণ।
— বেনজামিন লিন্ডলি
394

আপনার সংকলকটি যদি জিসিসি হয় তবে আপনি নিম্নলিখিত বাক্য গঠন ব্যবহার করতে পারেন:

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

বিস্তারিত বিবরণ দেখুন: http://gcc.gnu.org/onlinesocs/gcc-4.1.2/gcc/Designated-Inits.html

— qrdl
সূত্র
12
এবং সেই বাক্য গঠনটি সংকলিত বাইনারিগুলির ফাইল আকারে বিশাল বৃদ্ধি ঘটায়। এন = 65536 (1024 এর পরিবর্তে) এর জন্য, আমার বাইনারি 15 কেবি থেকে 270 কেবি আকারে লাফ দেয় !!
— সিটিন সার্ট
50
@ কেটিনসার্ট কমপাইলারকে intস্ট্যাটিক ডেটাতে 65536 গুলি যোগ করতে হবে , যা 256 কে - আপনি যে আকারের আকারটি দেখেছেন ঠিক সেটাই বাড়বে।
— qrdl
15
@ সেটিনসার্ট আমার কেন করা উচিত? এটি একটি স্ট্যান্ডার্ড সংকলক আচরণ, মনোনীত প্রারম্ভিকদের জন্য নির্দিষ্ট নয়। আপনি যদি স্ট্যাটিকালি 65536 intগুলি সূচনা করেন তবে আপনি int foo1 = 1, foo2 = 1, ..., foo65536 =1;একই আকারের বৃদ্ধি পাবেন।
— qrdl
27
আরও ভাল: "ইনট অ্যারে [] = {[0 ... 1023] = 5}", অ্যারের আকারটি স্বয়ংক্রিয়ভাবে 1024 এ সেট করা হবে, পরিবর্তন করা সহজ এবং নিরাপদ।
— ফ্রাঙ্কোইস
4
@ ফ্র্যাঙ্কোইস বা 2 ডি অ্যারের জন্য bool array[][COLS] = { [0...ROWS-1][0...COLS-1] = true}, যদিও আমি নিশ্চিত নই যে এটি সম্পূর্ণ ফর্মের চেয়ে বেশি পাঠযোগ্য।
— g33kz0r
178

একাধিক অনুলিপি-পেস্ট ব্যতীত একই মান সহ বৃহত অ্যারে স্থিতিশীল করার জন্য, আপনি ম্যাক্রোগুলি ব্যবহার করতে পারেন:

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

ম্যাক্রোর নামগুলি আলোচনা সাপেক্ষে।

— mouviciel
সূত্র
12
আমি কেবল এটি চরম ক্ষেত্রে বিবেচনা করব, অবশ্যই একটি স্মৃতি এটির প্রকাশ করার আরও মার্জিত উপায়।
— u0b34a0f6ae
47
যদি ডেটা অবশ্যই রম-সক্ষম হতে পারে তবে মেমসেট ব্যবহার করা যাবে না।
— অধ্যাপক ফ্যালকেন চুক্তি
9
প্রিপ্রসেসর আসলে # ডিফাইন থেকে কোড উত্পন্ন করবে। বৃহত্তর অ্যারের মাত্রার সাথে এক্সিকিউটেবল আকার বাড়বে। তবে অবশ্যই + ধারণার জন্য;)
— লিওনিড
7
@ অ্যালকোট, পুরানো কম্পিউটারগুলিতে এবং এখনও অনেক এম্বেড থাকা সিস্টেমে কোডটি শেষ পর্যন্ত একটি ইপ্রোম বা রমে রাখা হয় । এমও এম্বেড সিস্টেমে রম-সক্ষম এর অর্থও এসেছে, "ফ্ল্যাশড কোড লাগানো", কারণ এর প্রায় একইরকম প্রভাব রয়েছে, যথা স্মৃতিতে রানটাইম লেখা যায় না। আই মেমসেট বা মেমরি আপডেট বা পরিবর্তন করতে অন্য কোনও নির্দেশ ব্যবহার করা যাবে না। কনস্ট্যান্টগুলি যদিও প্রোগ্রামটি শুরু হওয়ার আগেই প্রকাশ করা যায় এবং ফ্ল্যামশ বা রম-এড করতে পারে।
— অধ্যাপক ফ্যালকেন চুক্তি
4
@ u0b34a0f6ae: মনে রাখবেন যে আপনি যদি এই পদ্ধতিটি VAL_1Xএকক পূর্ণসংখ্যার তালিকা নাও ব্যবহার করেন তবে এটি ব্যবহার করতে পারেন । এমিগেবল স্টেটসগুলির মতো, এম্বেড থাকা সিস্টেমগুলিতে যাওয়ার উপায় এটি যেখানে আপনি একটি EEPROM বা ফ্ল্যাশ মেমরির init মানগুলি সংজ্ঞায়িত করতে চান। উভয় ক্ষেত্রেই আপনি ব্যবহার করতে পারবেন না memset()।
— মার্টিন Scharrer
63

আপনি যদি নিশ্চিত করতে চান যে অ্যারের প্রতিটি সদস্য সুস্পষ্টভাবে সূচনা করা হয়েছে, কেবলমাত্র ঘোষণা থেকে মাত্রা বাদ দিন:

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 myPoints[10][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };
— প্রবীণ গৌড় চতুর্থ
10
না আপনি অন্তর্নিহিত মাত্রা বাদ দিচ্ছেন যা অনুমোদিত নয়। এটি একটি সংকলক ত্রুটি দেবে।
— ফ্রাঙ্ক এস্কজারবা
4
আরম্ভকারী এবং দৈর্ঘ্যের অনুমান উভয়ই C99 এ চালু হয়েছিল।
— প্লেকে
3
@ প্লেক: না - প্রাক-মান সি এর দিনগুলি (যেহেতু কেএন্ডআর প্রথম সংস্করণ প্রকাশিত হয়েছিল, এবং সম্ভবত এর কিছুক্ষণ আগে) দৈর্ঘ্যের অনুমান সি তে রয়েছে। মনোনীত ইনিশিয়ালাইজারগুলি সি 99 এ নতুন ছিল তবে এটি মনোনীত আরম্ভকারী ব্যবহার করছে না।
— জোনাথন লেফলার
53

আমি এমন কিছু কোড দেখেছি যা এই বাক্য গঠনটি ব্যবহার করেছে:

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

এটি বিশেষত কার্যকর হয়ে ওঠে যদি আপনি এমন একটি অ্যারে তৈরি করেন যা এনামগুলিকে সূচক হিসাবে ব্যবহার করে:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

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

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

এটি এনাম-মানগুলির ক্রমবর্ধমান কিছু লিখতে গেলেও বিষয়গুলিকে সুশৃঙ্খল রাখে।

এই কৌশল সম্পর্কে আরও এখানে এবং এখানে পাওয়া যাবে ।

— abelenky
সূত্র
8
এটি ইতিমধ্যে অন্যান্য উত্তরগুলির দ্বারা কভার করা C99 ইনিশিয়ালাইজার সিনট্যাক্স। আপনি কার্যকরভাবে এই ঘোষণাটি char const *array[] = { ... };এমনকি এর মধ্যেও char const * const array[] = { ... };করতে পারেন, পারছেন না?
— জোনাথন লেফলার
22 
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...

অ্যারের পরিবর্তনের আকারকে আবদ্ধ করুন।

— Tarski
সূত্র
12
রেকর্ডের জন্য, এটি মূলত কেবল একটি ধীর এবং আরও ভার্জোজ সংস্করণmemset(myArray, VALUE, ARRAY_SIZE);
— বেনসন
18
আপনি কীভাবে 255 এর চেয়ে বড় মানের কোনও ইন্টি অ্যারে শুরু করতে মেমসেট ব্যবহার করবেন? অ্যারে বাইট আকারের হলে মেমসেটটি কেবল কাজ করে।
— ম্যাট
21
@ বেনসন: আপনি উপরের কোডটি মেমসেটের সাথে প্ল্যাটফর্মগুলিতে প্রতিস্থাপন করতে পারবেন না যেখানে মাপের (ইন্টি)> মাপের (চর)। চেষ্টা করে দেখুন
— ক্রিসউইউ
13

আপনি উপরে বর্ণিত হিসাবে পুরো স্ট্যাটিক ইনিশিয়ালাইজার জিনিসটি করতে পারেন, তবে আপনার অ্যারের আকার পরিবর্তিত হলে (যখন আপনার অ্যারে অ্যালিজেনগুলি, আপনি যদি অতিরিক্ত অতিরিক্ত প্রারম্ভিক সংযোজন না করেন তবে আবর্জনা পান) তবে এটি সত্যিকারের বাউমার হতে পারে।

মেমসেট আপনাকে কাজটি করার জন্য একটি রানটাইম হিট দেয়, তবে কোনও কোড সাইজ হিট সঠিকভাবে সম্পন্ন করা হয় অ্যারের আকার পরিবর্তনের জন্য সুরক্ষা নয়। যদি অ্যারে কয়েক ডজন উপাদানগুলির চেয়ে বড় হয়ে থাকে তখন আমি প্রায় সমস্ত ক্ষেত্রেই এই সমাধানটি ব্যবহার করব।

যদি অ্যারেটি স্থিতিশীলভাবে ঘোষণা করা সত্যিই গুরুত্বপূর্ণ ছিল, আমি আমার জন্য প্রোগ্রামটি লিখতে একটি প্রোগ্রাম লিখতাম এবং এটি বিল্ডিং প্রক্রিয়ার অংশ করে তুলতাম।

— থামাল
সূত্র
আপনি দয়া memsetকরে অ্যারে আরম্ভ করতে ব্যবহারের জন্য কিছু উদাহরণ যুক্ত করতে পারেন ?
— সোপালাজো ডি অ্যারিরেজ
8

এখানে অন্য উপায়:

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

তারপরে প্রশ্ন জিজ্ঞাসা করুন: কে কখন সি এক্সটেনশন ব্যবহার করতে পারে?

উপরের কোড নমুনা এমবেডড সিস্টেমে রয়েছে এবং অন্য সংকলক থেকে আর কখনও আলো দেখবে না।

— humble_guru
সূত্র
6

'সাধারণ' ডাটা টাইপের (ইনট অ্যারেগুলির মতো) প্রারম্ভিককরণের জন্য, আপনি বন্ধনী স্বরলিপিটি ব্যবহার করতে পারেন, তবে অ্যারের মধ্যে এখনও স্থান না থাকলে এটি শেষের পরে মানগুলি শূন্য করবে:

// put values 1-8, then two zeroes
int list[10] = {1,2,3,4,5,6,7,8};
— ঘনবসতিপূর্ণ বস্তি
সূত্র
5

অ্যারেটি যদি ইন্টির আকার বা আপনার মেম-প্যাটার্নের আকার সহ কোনও কিছু ঘটে থাকে তবে কোনও সঠিক সময়ের (যেমন সমস্ত শূন্য বা 0xA5A5A5A5) ফিট করে, তবে মেমসেট () ব্যবহার করার সর্বোত্তম উপায় ।

অন্যথায় সূচককে সরানো একটি লুপে মেমকি () কল করুন।

— ddimitrov
সূত্র
5

কিছুটা জিভ-ইন-গাল উত্তর; বিবৃতি লিখুন

array = initial_value

আপনার পছন্দসই অ্যারে-সক্ষম ভাষায় (আমার ফোর্টরান, তবে আরও অনেকগুলি রয়েছে), এবং এটি আপনার সি কোডের সাথে যুক্ত করুন। বাহ্যিক ক্রিয়াকলাপ হিসাবে আপনি সম্ভবত এটি মুড়িয়ে রাখতে চান।

— উচ্চ পারফরম্যান্স মার্ক
সূত্র
4

প্রদত্ত মান সহ যে কোনও ধরণের অ্যারে শুরু করার একটি দ্রুত উপায় রয়েছে। এটি বড় অ্যারেগুলির সাথে খুব ভালভাবে কাজ করে। অ্যালগরিদম নিম্নরূপ:

  • অ্যারের প্রথম উপাদানটি শুরু করুন (স্বাভাবিক উপায়)
  • অনুলিপি অংশ যা ভাগ করা হয়েছে যা সেট করা হয়নি, প্রতিটি পরবর্তী অনুলিপি অপারেশন দিয়ে আকার দ্বিগুণ

জন্য 1 000 000উপাদান intঅ্যারের এটা 4 বার নিয়মিত লুপ আরম্ভের (i5- এ, 2 কোর, 2.3 গিগাহার্জ, 4GiB মেমরি, 64 বিট) তুলনায় দ্রুততর হল:

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;
}
— Maciej
সূত্র
2
দুঃখিত, তবে এটি সত্য নয়। হতে পারে আপনি আপনার পরীক্ষার সময় সংকলন অপ্টিমাইজেশন চালু করতে ভুলে গেছেন (ডিবাগ মোডের সাথে পরীক্ষিত?) আমি যদি এটি পরীক্ষা করি তবে লুপটি প্রায় সবসময় মেমফিলের চেয়ে প্রায় 50% দ্রুত (আমার কম্পিউটারে কিছু লোড জিটারের কারণে 'সর্বদা')। এবং মেমসেট ব্যবহার করে (ক, 0, আকারের (ক)); লুপফিলের চেয়ে দ্বিগুণ দ্রুত।
— আরএস 1980
2
যে কোনও বেঞ্চমার্কিং কোডের মতো আপনারও অত্যন্ত সতর্ক হওয়া দরকার। টাইমিং কোডটি 10 ​​বার কার্যকর করার জন্য একটি লুপ যুক্ত করা (এবং অ্যারেটির আকার 20M তে দ্বিগুণ করা) শো করে - আমার জন্য, ম্যাকবুক প্রোতে ম্যাকস সিয়েরা 10.12.3 দিয়ে চলছে এবং জিসিসি 6.3.0 ব্যবহার করে - যা প্রথমবার ব্যবহার করে লুপটি প্রায় 4600 µ গুলি লাগে, যখন memfill()কোডটি 1200 µ প্রায় লাগে। যাইহোক, পরবর্তী পুনরাবৃত্তিতে, লুপটি প্রায় 900-1000 takes সময় memfill()লাগে যখন কোডটি 1000-1300 µ নেয়। প্রথম পুনরাবৃত্তি সম্ভবত ক্যাশে পূরণের সময় দ্বারা প্রভাবিত হয়। পরীক্ষার বিপরীত এবং memfill()প্রথমবার ধীর।
— জোনাথন লেফলার
2

কেউ প্রাথমিক সূচকের উপাদানগুলির অ্যাক্সেসের জন্য সূচক আদেশের কথা উল্লেখ করেনি। আমার উদাহরণ কোড এটিতে একটি উদাহরণস্বরূপ উদাহরণ দেবে।

#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
— hkBattousai
সূত্র
4
<iostream>বৈধ নয় Cযেমন std::cout, std::cinইত্যাদি অংশ std::namespaceএবং Cসমর্থন করে না namespaces। পরিবর্তে ব্যবহার <stdio.h>করার চেষ্টা করুন printf(...)।
— ফ্রান্সিস কুগার 19
2

সমস্ত বকবক কাটা, সংক্ষিপ্ত উত্তরটি হ'ল সংকলনের সময় আপনি যদি অপ্টিমাইজেশন চালু করেন তবে আপনি এর থেকে ভাল আর করতে পারবেন না: 

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

যুক্ত বোনাস: কোডটি আসলে সুস্পষ্ট :)

— JWDN
সূত্র
7
প্রশ্নটি বিশেষত আরম্ভের জন্য জিজ্ঞাসা করেছিল। এটি সুস্পষ্টভাবে আরম্ভ নয়, অ্যাসাইনমেন্টের পরে কার্য সম্পাদন করা হয়েছে। এটি অবিলম্বে সম্পন্ন হতে পারে তবে এটি এখনও আরম্ভ নয়।
— অ্যান্ডি
বহুবার ডাকা ফাংশনের অভ্যন্তরে কোনও বৃহত স্ট্যাটিক লুক টেবিলের জন্য পুরোপুরি সহায়ক নয়।
— মার্টিন বোনার
... মূল প্রশ্নের অংশ হয়ে ফাংশনগুলির অভ্যন্তরে স্থির দেখার সারণীগুলি মনে রাখবেন না - এটিকে সহজ রাখুন। এটি বলেছিল, @ কম্যুনিটি সম্ভবত এটি পেরেক দিয়েছে।
— জেডব্লিউডিএন
1
  1. যদি আপনার অ্যারে স্থির হিসাবে ঘোষিত হয় বা বিশ্বব্যাপী, অ্যারের সমস্ত উপাদানগুলির মধ্যে ইতিমধ্যে ডিফল্ট মান 0 থাকে।
  2. কিছু সংকলক ডিবাগ মোডে অ্যারের ডিফল্ট 0 তে সেট করে।
  3. 0: int অ্যারেতে ডিফল্ট সেট করা সহজ [10] = {0};
  4. তবে অন্যান্য মানগুলির জন্য আপনার কাছে মেমসেট () বা লুপ ব্যবহার রয়েছে;

উদাহরণস্বরূপ: int অ্যারে [10]; মেমসেট (অ্যারে, -1, 10 * আকারের (ইনট));

— হান্না ঝাং
সূত্র
0 
#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 ...... দেবে

— দধিচ সৌরভ
সূত্র
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];সরাসরি ঘোষণার পরে আরম্ভ হয় না, তবে খুব পরের কোড ব্লক বা ফাংশন কল অ্যারের প্রতিটি উপাদানকে আপনার পছন্দ মতো একই মানের সাথে আরম্ভ করে। অন্য সাবধানবাণীটি হ'ল, আপনাকে সমর্থন করা initializing functionপ্রত্যেকটির জন্য typeআপনাকে একটি লিখতে হবে এবং আপনাকে এটিটি সংশোধন করতে হবেprintArray() এই ধরণের সমর্থনের ফাংশনটিও ।

আপনি এখানে পাওয়া একটি অনলাইন কম্পাইলার সহ এই কোডটি চেষ্টা করতে পারেন ।

— ফ্রান্সিস কুগার
সূত্র
0

বিলম্বিত আরম্ভের জন্য (যেমন শ্রেণীর সদস্য নির্মাণকারী আরম্ভ) বিবেচনা করুন:

int a[4];

unsigned int size = sizeof(a) / sizeof(a[0]);
for (unsigned int i = 0; i < size; i++)
  a[i] = 0;
— nikc
সূত্র
0

আমি জানি মূল প্রশ্নটি স্পষ্টভাবে সি এবং সি ++ এর উল্লেখ করেছে না, তবে আপনি (আমার মতো) যদি সি ++ অ্যারেগুলির সমাধান খুঁজতে এসেছিলেন তবে এখানে একটি ঝরঝরে কৌশল আছে:

যদি আপনার সংকলক ভাঁজ এক্সপ্রেশন সমর্থন করে , আপনি টেমপ্লেট যাদু ব্যবহার করতে পারেন এবং 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

আপনি কর্মক্ষেত্রের কোডটি দেখতে পারেন (ওয়্যান্ডবক্সে)

— ক্লেম্যানস সিলাফ
সূত্র
-1

আমি প্রশ্নের কোনও প্রয়োজনীয়তা দেখতে পাচ্ছি না, সুতরাং সমাধানটি অবশ্যই জেনেরিক হতে হবে: প্রাথমিক সদস্যের মান সহ অনির্ধারিত সম্ভবত কাঠামোগত উপাদানগুলির দ্বারা নির্মিত একটি অনির্দিষ্ট সম্ভবত বহুমাত্রিক অ্যারের সূচনা:

#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

— sambowry
সূত্র
1
আমি সন্দিহান এটি সমাধান কিনা। sizeof(void)এমনকি বৈধ কিনা তা আমি নিশ্চিত নই ।
— ক্রিস লুটজ
3
এটি কাজ করে না। কেবলমাত্র প্রথম দুটি সূচনা করা হয়েছে, বাকিগুলি সমস্তই অবিচ্ছিন্ন। আমি ম্যাক ওএস এক্স 10.4 এ জিসিসি 4.0 ব্যবহার করছি।
— ড্রিমলাক্স
এটি অপরিজ্ঞাত আচরণের জন্য আহ্বান করে কারণ দ্বিতীয়টিতে উত্সের ডেটা memcpy()গন্তব্য স্থানের সাথে ওভারল্যাপ করে। নির্বিকার প্রয়োগের সাথে memcpy(), এটি কাজ করতে পারে তবে এটির প্রয়োজন হয় না যে সিস্টেম এটি কাজ করে।
— জোনাথন লেফলার
-1

আগের দিন (এবং আমি এটি একটি ভাল ধারণা বলছি না), আমরা প্রথম উপাদানটি সেট করব এবং তারপরে:

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

এমনকি এটি আরও কাজ করবে কিনা তা নিশ্চিত নয় (এটি ম্যাকপি প্রয়োগের উপর নির্ভর করবে) তবে এটি প্রাথমিক উপাদানটিকে পরবর্তী বারে অনুলিপি করে কাজ করে - এমনকি কাঠামোর অ্যারেগুলির জন্যও কাজ করে।

— মাইক
সূত্র
এটি নির্ভরযোগ্যভাবে কাজ করবে না। আইএমএইচও, স্ট্যান্ডার্ডটি memcpyওভারল্যাপের ক্ষেত্রে নির্দিষ্ট মতো নীচে বা নীচের অংশের উপরের কপিরাইট অর্ডারের মতো ফাংশন সরবরাহ করা উচিত ছিল , তবে তা হয় না।
— সুপারক্যাট
যেমনটি আমি বলেছিলাম, এটি এমন কিছু ছিল যা আমরা নির্ভরযোগ্যভাবে কাজ করি না তবে তারপরে, আমরা অনিদ্রিত বৈশিষ্ট্যগুলি এড়িয়ে যাওয়ার চেয়ে দক্ষতার দিকে বেশি মনোনিবেশ করেছিলাম। মেমোরি ফরওয়ার্ডগুলি অনুলিপি করা আরও দক্ষ, তবে এটি এলোমেলো ক্রম হিসাবে এটি পিছন দিকে অনুলিপি করতে বা একাধিক থ্রেডে বিভক্ত করতে পারে না তা বলার জন্য নির্দিষ্টকরণের কিছুই নেই nothing memmove () সংঘর্ষ ছাড়াই অনুলিপি করার ক্ষমতা সরবরাহ করে।
— মাইক
এটি অন্য উত্তরে কোডের সমতুল্য - এবং ত্রুটিযুক্ত। ব্যবহার memmove()করে এটি কাজ করে না।
— জোনাথন লেফলার
-2

আপনি যদি সমান্তরালভাবে বোঝাতে চান, তবে আমি মনে করি যে কমা অপারেটর যখন কোনও অভিব্যক্তির সাথে মিলিতভাবে ব্যবহৃত হয় তখন এটি করতে পারে: 

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 / বরাদ্দ / ইত্যাদিতে কল করতে পারেন:

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

এবং এর দ্বারা সদস্যদের অ্যাক্সেস করুন:

*(array + index)

প্রভৃতি

— pchelper4
সূত্র
কমা অপারেটর নামমাত্র বাম থেকে ডান মূল্যায়নের গ্যারান্টি দেয়। এক্সপ্রেশনগুলিতে যদি কোনও পার্শ্ব-প্রতিক্রিয়া না থাকে, তবে অপারেশনগুলিকে সমান্তরাল করে তোলা সম্ভব হতে পারে তবে সংকলকটির পক্ষে এটি করা অস্বাভাবিক হবে।
— জোনাথন লেফলার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.