কীভাবে মুছবেন [] এটি জানেন যে এটি একটি অ্যারে?

Question

ঠিক আছে, আমি মনে করি আমরা সকলেই একমত হই যে নিম্নলিখিত কোডটি দিয়ে যা ঘটে তা পূর্বনির্ধারিত, যা পাস হয় তার উপর নির্ভর করে,

void deleteForMe(int* pointer)
{
     delete[] pointer;
}

পয়েন্টারটি বিভিন্ন ধরণের বিভিন্ন জিনিস হতে পারে এবং সুতরাং delete[]এটিতে একটি শর্তহীন সম্পাদন করা অনির্ধারিত। তবে, ধরে নেওয়া যাক আমরা সত্যই একটি অ্যারে পয়েন্টারটি পাস করছি,

int main()
{
     int* arr = new int[5];
     deleteForMe(arr);
     return 0;
}

আমার প্রশ্ন এই ক্ষেত্রে যেখানে পয়েন্টার মধ্যে হয় হয় একটি অ্যারের, কে যে এই জানে? আমি বলতে চাইছি ভাষা / সংকলকের দৃষ্টিকোণ থেকে এটি কোনও ধারণা নেই arrযা একটি বিন্যাসের তুলনায় একটি অ্যারে পয়েন্টার বনাম একটি একক প্রান্তের কাছে । মুরগি, এটি এমনকি জানে না arrযে গতিশীলভাবে তৈরি হয়েছিল কিনা । তবুও, যদি আমি পরিবর্তে নিম্নলিখিতটি করি,

int main()
{
     int* num = new int(1);
     deleteForMe(num);
     return 0;
}

ওএস কেবলমাত্র একটি ইনট মুছতে পারে এবং সেই বিন্দুটি অতিক্রম করে বাকি স্মৃতিটি মুছে ফেলে কোনও ধরণের 'কিলিং স্প্রি' না চালানোর পক্ষে যথেষ্ট (এটি বিপরীতে strlenএবং একটি \0নির্ধারিত স্ট্রিংয়ের সাথে বিপরীতে থাকে - এটি এটি অবিরত চলতে থাকবে হিট 0)।

তাহলে এসবের কথা মনে রাখা কার কাজ? ওএস কি ব্যাকগ্রাউন্ডে কিছু ধরণের রেকর্ড রাখে? (এর অর্থ, আমি বুঝতে পারি যে আমি এই পোস্টটি এই বলে শুরু করেছিলাম যে যা ঘটে তা অনির্ধারিত, তবে আসল ঘটনাটি হ'ল 'হত্যার স্প্রাই' দৃশ্যটি ঘটে না, তাই বাস্তব বিশ্বে কেউ মনে রাখছে is)

Comments

সম্পর্কিত: অপারেন্ড অ্যারের আকারটি "কীভাবে" মুছবে?

— শ্রীভাতসার আর

এটি মুছে ফেলার পরে স্কোয়ার বন্ধনীগুলি থেকে জানে

— জোয়েলফ্যান

"পয়েন্টারটি একটি অ্যারে"। না, পয়েন্টারগুলি কখনই অ্যারে হয় না। তারা প্রায়শই অ্যারের প্রথম উপাদানটিকে নির্দেশ করে তবে এটি একটি ভিন্ন জিনিস।

— অ্যারন ম্যাকডেইড

Answer 1

সংকলক জানে না এটি একটি অ্যারে, এটি প্রোগ্রামারকে বিশ্বাস করে। একটি একক একটি পয়েন্টার মোছা intসঙ্গে delete []অনির্ধারিত আচরণের পরিণাম হবে। আপনার দ্বিতীয় main()উদাহরণটি অনিরাপদ, এমনকি যদি এটি অবিলম্বে ক্রাশ না হয়।

সংকলকটি কতটা অবজেক্টকে কোনওভাবে মুছে ফেলার প্রয়োজন তা ট্র্যাক করে রাখতে হবে। এটি অ্যারের আকার সংরক্ষণ করার জন্য পর্যাপ্ত পরিমাণে বরাদ্দ করে এটি করতে পারে। আরও তথ্যের জন্য, সি ++ সুপার এফএকিউ দেখুন ।

Comments

আসলে, নতুন দিয়ে তৈরি কিছু মুছতে মুছতে [] মুছে ফেলা ব্যবহার করা সুবিধাজনক। taossa.com/index.php/2007/01/03/…

— রডরিগো

@ রডরিগো আপনার মন্তব্যের লিঙ্কটি নষ্ট হয়ে গেছে, তবে ধন্যবাদ যে ওয়েবেব্যাক মেশিনটির এটির একটি অনুলিপি replay.web.archive.org/20080703153358/http://taossa.com/… এ আছে

— ডেভিড গার্ডনার

Answer 2

একটি প্রশ্ন যা এখনও অবধি দেওয়া উত্তরগুলি সম্বোধন করে বলে মনে হচ্ছে না: যদি রানটাইম লাইব্রেরিগুলি (ওএস নয়, সত্যই) অ্যারেতে থাকা সংখ্যার উপর নজর রাখতে পারে, তবে আমাদের কেন delete[]সিনট্যাক্সের দরকার নেই ? deleteসমস্ত মুছে ফেলতে হ্যান্ডেল করতে কেন একটি ফর্ম ব্যবহার করা যায় না?

এর উত্তর সি ++ এর মূলগুলিতে সি-সামঞ্জস্যপূর্ণ ভাষা হিসাবে ফিরে আসে (যা এটি আর বাস্তবে হওয়ার চেষ্টা করে না)) স্ট্রাস্ট্রুপের দর্শন ছিল প্রোগ্রামারকে এমন কোনও বৈশিষ্ট্য ব্যবহার করতে হবে না যা তারা ব্যবহার করছে না। যদি তারা অ্যারে ব্যবহার না করে তবে মেমরির প্রতিটি বরাদ্দ অংশের জন্য তাদের অবজেক্ট অ্যারেগুলির ব্যয় বহন করা উচিত নয়।

এটি হ'ল, যদি আপনার কোডটি সহজভাবে করে

Foo* foo = new Foo;

তারপরে যে মেমরি স্পেসের জন্য বরাদ্দ করা হয়েছে fooতাতে কোনও অতিরিক্ত ওভারহেড অন্তর্ভুক্ত করা উচিত নয় যা অ্যারে সমর্থন করার জন্য প্রয়োজন Foo।

যেহেতু অতিরিক্ত অ্যারের আকারের তথ্য বহন করার জন্য কেবল অ্যারে বরাদ্দগুলি সেট আপ করা হয়, তারপরে আপনি যখন অবজেক্টগুলি মুছবেন তখন সেই তথ্যটি অনুসন্ধানের জন্য রানটাইম লাইব্রেরিগুলিকে আপনাকে বলতে হবে। এজন্য আমাদের ব্যবহার করা দরকার

delete[] bar;

পরিবর্তে ন্যায়বিচার

delete bar;

যদি বারটি অ্যারের নির্দেশক হয়।

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

Comments

"মেমরির কয়েকটি অতিরিক্ত বাইট সম্পর্কে হতাশাই আজকাল বিশ্রী মনে হচ্ছে"। ভাগ্যক্রমে, এই জাতীয় লোকের কাছে খালি অ্যারেগুলিও কমন দেখতে শুরু করেছে, তাই তারা কেবল কোনও ভেক্টর বা বুস্ট :: অ্যারে ব্যবহার করতে পারে এবং মুছে ফেলার কথা ভুলে যেতে পারে [] চিরকালের জন্য :-)

— স্টিভ জেসপ

Answer 3

হ্যাঁ, ওএস কিছু ব্যাকগ্রাউন্ডে রাখে। উদাহরণস্বরূপ, যদি আপনি চালান

int* num = new int[5];

ওএস 4 টি অতিরিক্ত বাইট বরাদ্দ করতে পারে, বরাদ্দের মাপের প্রথম 4 বাইটে বরাদ্দ মেমরির বরাদ্দ করতে পারে এবং অফসেট পয়েন্টারটি ফেরত দিতে পারে (যেমন এটি মেমরি স্পেসগুলি 1000 থেকে 1024 এ বরাদ্দ করে তবে পয়েন্টারটি 1000- এর অবস্থান সহ 1004 এ পয়েন্ট দেয়) 1003 বরাদ্দের আকার সংরক্ষণ করে)। তারপরে, মুছুন যখন ডাকা হয়, বরাদ্দটির আকার খুঁজতে পয়েন্টারটি পাস করার আগে এটি 4 বাইট দেখতে পারে at

আমি নিশ্চিত যে বরাদ্দের আকার ট্র্যাক করার অন্যান্য উপায় আছে তবে এটি একটি বিকল্প।

Comments

+1 - বৈধ পয়েন্ট ব্যতীত সাধারণভাবে ভাষা রানটাইম এই মেটাডেটা সংরক্ষণের জন্য দায়ী, না ওএস।

— শার্পথুথ

অ্যারের সংজ্ঞাযুক্ত কোন বস্তুর অ্যারে বা আকারের কি হবে? আপনি যখন সেই অবজেক্টে একটি মাপের কাজ করেন তখন এটি কী অতিরিক্ত 4 বাইট দেখায়?

— শ্রী

না, আকারে অ্যারের আকারটি দেখায়। রানটাইম যদি ডাব্লু / পদ্ধতিটি বর্ণনা করে এটি বাস্তবায়ন করতে পছন্দ করে তবে এটি কঠোরভাবে বাস্তবায়নের বিশদ এবং ব্যবহারকারীর দৃষ্টিকোণ থেকে, এটি মাস্ক করা উচিত। পয়েন্টারের আগে থাকা স্মৃতিটি ব্যবহারকারীর সাথে 'সম্পর্কিত নয়' এবং গণনা হয় না।

— বিএসডিফিশ

আরও গুরুত্বপূর্ণ, মাপের কোনও ক্ষেত্রে গতিশীল বরাদ্দকৃত অ্যারের সত্যিকারের আকারটি ফেরৎ দেবে না। এটি কেবল সংকলনের সময় পরিচিত আকারগুলি ফিরিয়ে দিতে পারে।

— বিডোনলান

অ্যারে থেকে সঠিকভাবে লুপ করতে কোনও লুপের জন্য এই মেটাডেটা ব্যবহার করা কি সম্ভব? যেমন for(int i = 0; i < *(arrayPointer - 1); i++){ }

— স্যাম

Answer 4

এটি এই প্রশ্নের সাথে খুব সাদৃশ্যপূর্ণ এবং এটি আপনার সন্ধান করছেন এমন অনেকগুলি বিবরণ রয়েছে।

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

নিম্নলিখিত কোডটি কার্যকর করে কিছু বাস্তবায়নে এটি দৃশ্যমান

int* pArray = new int[5];
int size = *(pArray-1);

Comments

এই কাজ করবে? উইন্ডোজ এবং লিনাক্সে আমরা এই কাজটি করতে পারি নি।

— বন্ধু

size_t size = *(reinterpret_cast<size_t *>(pArray) - 1)পরিবর্তে চেষ্টা করুন

Answer 5

deleteঅথবা delete[]সম্ভবত দুজনেই বরাদ্দকৃত মেমরিটি মুক্ত করে দেবে (মেমরি পয়েন্টেড), তবে বড় পার্থক্যটি হ'ল deleteঅ্যারেতে অ্যারের প্রতিটি উপাদানগুলির ডেস্ট্রাক্টরকে কল করবে না।

যাইহোক, মেশানো new/new[]এবং delete/delete[]সম্ভবত ইউবি হয়।

Comments

পরিষ্কার, সংক্ষিপ্ত এবং সবচেয়ে দরকারী উত্তর!

— GntS

Answer 6

এটি এটি অ্যারে জানে না, এজন্য আপনাকে delete[]নিয়মিত পুরানোের পরিবর্তে সরবরাহ করতে হবে delete।

Answer 7

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

সুতরাং কেন এটি সিতে আপনি কেবল পয়েন্টারটি বিনামূল্যে দিতে পারেন, তবে সি ++ এ আপনাকে অবশ্যই এটি অবশ্যই বলতে হবে এটি অ্যারে বা একক পরিবর্তনশীল কিনা?

উত্তরটি, আমি শিখেছি, ক্লাস ধ্বংসকারীদের সাথে কাজ করতে হবে।

আপনি যদি ক্লাস মাই ক্লাসের উদাহরণ বরাদ্দ করেন ...

classes = new MyClass[3];

এবং মুছে ফেলুন সহ এটি মুছুন, আপনি কেবলমাত্র মাইক্লাসের প্রথম বারের জন্য ডাস্ট্রেক্টর পেতে পারেন। আপনি যদি মুছে ফেলা []] ব্যবহার করেন তবে আপনাকে নিশ্চিত করা যেতে পারে যে অ্যারেতে সমস্ত দৃষ্টান্তের জন্য ধ্বংসকারীকে ডাকা হবে।

এটি গুরুত্বপূর্ণ পার্থক্য। যদি আপনি কেবল স্ট্যান্ডার্ড ধরণের (উদাহরণস্বরূপ) দিয়ে কাজ করছেন তবে আপনি সত্যিই এই সমস্যাটি দেখতে পাবেন না। এছাড়াও, আপনার মনে রাখা উচিত যে নতুন [] এবং মুছে ফেলার জন্য [] মুছে ফেলা ব্যবহার করার আচরণটি অপরিজ্ঞাত - এটি প্রতিটি সংকলক / সিস্টেমে একইভাবে কাজ করতে পারে না।

Answer 8

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

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

Answer 9

সংকলকগুলির জন্য একটি পদ্ধতির মধ্যে হ'ল মাথার উপাদানটিতে কিছুটা বেশি মেমরি এবং উপাদান গণনা সঞ্চয় করা বরাদ্দ করা।

এটি কীভাবে করা যায় তার উদাহরণ: এখানে

int* i = new int[4];

সংকলক আকার (int) * 5 বাইট বরাদ্দ করবে।

int *temp = malloc(sizeof(int)*5)

4প্রথম sizeof(int)বাইটে সঞ্চয় করবে

*temp = 4;

এবং সেট i

i = temp + 1;

সুতরাং i5 নয়, 4 টি উপাদানের অ্যারে নির্দেশ করে।

এবং

delete[] i;

নিম্নলিখিত পদ্ধতিতে প্রক্রিয়া করা হবে

int *temp = i - 1;
int numbers_of_element = *temp; // = 4
... call destructor for numbers_of_element elements if needed
... that are stored in temp + 1, temp + 2, ... temp + 4
free (temp)

Answer 10

শব্দার্থকভাবে, সি ++ এ মুছুন অপারেটরের উভয় সংস্করণই কোনও পয়েন্টারকে "খেতে" পারে; যাইহোক, যদি কোনও একক বস্তুর পয়েন্টার দেওয়া হয় delete[], তবে ইউবি ফলাফল করবে, যার অর্থ সিস্টেম ক্র্যাশ বা কিছুই নয়, যা কিছু ঘটতে পারে।

সি ++ এর জন্য প্রোগ্রামারকে মুছে ফেলা অপারেটরের যথাযথ সংস্করণটি ডিএলোকেশন বিষয়টির উপর নির্ভর করে চয়ন করতে হবে: অ্যারে বা একক বস্তু।

মুছে ফেলা অপারেটরের কাছে পাঠানো কোনও পয়েন্টারটি পয়েন্টার অ্যারে কিনা তা যদি সংকলক স্বয়ংক্রিয়ভাবে নির্ধারণ করতে পারে, তবে সি ++ এ কেবল একটি মুছুন অপারেটর থাকবে যা উভয় ক্ষেত্রেই যথেষ্ট।

Answer 11

সম্মত হন যে সংকলকটি এটি অ্যারে কিনা তা জানে না। এটি প্রোগ্রামার উপর নির্ভর করে।

সংকলক মাঝে মাঝে অ্যারের আকার সংরক্ষণ করার জন্য পর্যাপ্ত পরিমাণে বরাদ্দ দিয়ে কতগুলি অবজেক্ট মুছতে হবে তা ট্র্যাক করে রাখে তবে সর্বদা প্রয়োজনীয় নয়।

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

Comments

আমি কেবল প্রতিটি সংকলক সি ++ এর জন্য কিছু ডকুমেন্টেড এবিআই পর্যবেক্ষণ করতে চাই । লিঙ্কটির জন্য +1, যা আমি আগে গিয়েছিলাম। ধন্যবাদ।

— ডন ওয়েকফিল্ড

Answer 12

আপনি অ্যারের জন্য মুছুন ব্যবহার করতে পারবেন না , এবং আপনি অ-অ্যারের জন্য মুছুন [] ব্যবহার করতে পারবেন না ।

Comments

আমার মনে হয় আপনার বোঝানো উচিত নয়, কারণ আপনার গড় সংকলক অপব্যবহার শনাক্ত করতে পারে না।

— ডন ওয়েকফিল্ড

Answer 13

"অপরিজ্ঞাত আচরণ" এর অর্থ সহজভাবে বোঝা যায় যে ভাষাটি কী হবে তা কোনও গ্যারান্টি তৈরি করে না। এটি naceaceally এর অর্থ এই নয় যে খারাপ কিছু ঘটবে।

তাহলে এসবের কথা মনে রাখা কার কাজ? ওএস কি ব্যাকগ্রাউন্ডে কিছু ধরণের রেকর্ড রাখে? (এর অর্থ, আমি বুঝতে পারি যে আমি এই পোস্টটি এই বলে শুরু করেছিলাম যে যা ঘটে তা অনির্ধারিত, তবে আসল ঘটনাটি হ'ল 'হত্যার স্প্রাই' দৃশ্যটি ঘটে না, তাই বাস্তব বিশ্বে কেউ মনে রাখছে is)

এখানে সাধারণত দুটি স্তর রয়েছে। অন্তর্নিহিত মেমরি পরিচালক এবং সি ++ বাস্তবায়ন।

সাধারণভাবে মেমোরি ম্যানেজার মনে রাখবেন (অন্যান্য জিনিসের মধ্যে) বরাদ্দ করা মেমরির ব্লকের আকার। এটি সি ++ প্রয়োগের জন্য বলা ব্লকের চেয়ে বড় হতে পারে। সাধারণত মেমরির ম্যানেজার বরাদ্দ মেমরির ব্লক হওয়ার আগে এটি মেটাডেটা সংরক্ষণ করবে।

সি ++ বাস্তবায়ন কেবলমাত্র অ্যারের আকারটি মনে করতে পারে যদি তার নিজস্ব উদ্দেশ্যে এটি করার প্রয়োজন হয়, সাধারণত কারণ ধরণের একটি অ-ট্রিভাল ডেস্ট্রাক্টর রয়েছে।

তুচ্ছ ডেস্ট্রাক্টর সহ ধরণের ক্ষেত্রে "মুছুন" এবং "মুছুন []" এর প্রয়োগ সাধারণত একই রকম হয়। সি ++ বাস্তবায়ন কেবল অন্তর্নিহিত মেমরি পরিচালককে পয়েন্টারটি দেয়। কিছুটা এইরকম

free(p)

অন্যদিকে, অপ্রয়োজনীয় ডেস্ট্রাক্টর "মুছুন" এবং "মুছুন []" সহ ধরণের ক্ষেত্রে পৃথক হওয়ার সম্ভাবনা রয়েছে। "মুছুন" কিছুটা সমান হবে (যেখানে টি সেই ধরণের যেখানে পয়েন্টারটি নির্দেশ করে)

p->~T();
free(p);

"মুছে ফেলা []" এর মতো কিছু হবে।

size_t * pcount = ((size_t *)p)-1;
size_t count = *count;
for (size_t i=0;i<count;i++) {
  p[i].~T();
}
char * pmemblock = ((char *)p) - max(sizeof(size_t),alignof(T));
free(pmemblock);

Answer 14

অ্যারের অবজেক্টের মাধ্যমে পুনরাবৃত্তি করুন এবং তাদের প্রত্যেকের জন্য ডেস্ট্রাক্টর কল করুন। আমি এই সাধারণ কোড ডাইনিটি ওভারলোডগুলি নতুন [] এবং মুছে ফেলা [] এক্সপ্রেশন তৈরি করেছি এবং প্রতিটি বস্তুর জন্য মেমরি এবং ডেস্ট্রাক্টরকে কল করার জন্য একটি টেম্পলেট ফাংশন সরবরাহ করে:

// overloaded new expression 
void* operator new[]( size_t size )
{
    // allocate 4 bytes more see comment below 
    int* ptr = (int*)malloc( size + 4 );

    // set value stored at address to 0 
    // and shift pointer by 4 bytes to avoid situation that
    // might arise where two memory blocks 
    // are adjacent and non-zero
    *ptr = 0;
    ++ptr; 

    return ptr;
}
//////////////////////////////////////////

// overloaded delete expression 
void static operator delete[]( void* ptr )
{
    // decrement value of pointer to get the
    // "Real Pointer Value"
    int* realPtr = (int*)ptr;
    --realPtr;

    free( realPtr );
}
//////////////////////////////////////////

// Template used to call destructor if needed 
// and call appropriate delete 
template<class T>
void Deallocate( T* ptr )
{
    int* instanceCount = (int*)ptr;
    --instanceCount;

    if(*instanceCount > 0) // if larger than 0 array is being deleted
    {
        // call destructor for each object
        for(int i = 0; i < *instanceCount; i++)
        {
            ptr[i].~T();
        }
        // call delete passing instance count witch points
        // to begin of array memory 
        ::operator delete[]( instanceCount );
    }
    else
    {
        // single instance deleted call destructor
        // and delete passing ptr
        ptr->~T();
        ::operator delete[]( ptr );
    }
}

// Replace calls to new and delete
#define MyNew ::new
#define MyDelete(ptr) Deallocate(ptr)

// structure with constructor/ destructor
struct StructureOne
{
    StructureOne():
    someInt(0)
    {}
    ~StructureOne() 
    {
        someInt = 0;
    }

    int someInt;
};
//////////////////////////////

// structure without constructor/ destructor
struct StructureTwo
{
    int someInt;
};
//////////////////////////////


void main(void)
{
    const unsigned int numElements = 30;

    StructureOne* structOne = nullptr;
    StructureTwo* structTwo = nullptr;
    int* basicType = nullptr;
    size_t ArraySize = 0;

/**********************************************************************/
    // basic type array 

    // place break point here and in new expression
    // check size and compare it with size passed 
    // in to new expression size will be the same
    ArraySize = sizeof( int ) * numElements;

    // this will be treated as size rather than object array as there is no 
    // constructor and destructor. value assigned to basicType pointer
    // will be the same as value of "++ptr" in new expression
    basicType = MyNew int[numElements];

    // Place break point in template function to see the behavior
    // destructors will not be called and it will be treated as 
    // single instance of size equal to "sizeof( int ) * numElements"
    MyDelete( basicType );

/**********************************************************************/
    // structure without constructor and destructor array 

    // behavior will be the same as with basic type 

    // place break point here and in new expression
    // check size and compare it with size passed 
    // in to new expression size will be the same
    ArraySize = sizeof( StructureTwo ) * numElements;

    // this will be treated as size rather than object array as there is no 
    // constructor and destructor value assigned to structTwo pointer
    // will be the same as value of "++ptr" in new expression
    structTwo = MyNew StructureTwo[numElements]; 

    // Place break point in template function to see the behavior
    // destructors will not be called and it will be treated as 
    // single instance of size equal to "sizeof( StructureTwo ) * numElements"
    MyDelete( structTwo );

/**********************************************************************/
    // structure with constructor and destructor array 

    // place break point check size and compare it with size passed in
    // new expression size in expression will be larger by 4 bytes
    ArraySize = sizeof( StructureOne ) * numElements;

    // value assigned to "structOne pointer" will be different 
    // of "++ptr" in new expression  "shifted by another 4 bytes"
    structOne = MyNew StructureOne[numElements];

    // Place break point in template function to see the behavior
    // destructors will be called for each array object 
    MyDelete( structOne );
}
///////////////////////////////////////////

Answer 15

একটি ক্লাসের মধ্যে কেবল একটি ডেস্ট্রাক্টর সংজ্ঞায়িত করুন এবং উভয় বাক্য গঠন সহ আপনার কোডটি কার্যকর করুন

delete pointer

delete [] pointer

আউটপুট অনুযায়ী আপনি সমাধান পেতে পারেন

Comments

মুছুন [] আপনি যখন কোনও অ্যারে টাইপ করবেন তখন ব্যবহার করুন use উদাহরণস্বরূপ int * a = new int; ইনট * বি = নতুন ইনট [5]; মুছুন; মুছুন [] খ;

— লিনিশ কে মোহন

Answer 16

উত্তর:

int * pArray = new int [5];

int মাপ = * (পিআরএ -১);

উপরে পোস্ট করা সঠিক নয় এবং অবৈধ মান উত্পাদন করে। "-1" উপাদানগুলি গণনা করে 64 বিট উইন্ডোজ ওএসে সঠিক বাফার আকার পিটিআর - 4 বাইটের ঠিকানায় থাকে