আমার কাছে প্রোগ্রামগুলির ভিন্ন অংশ থেকে আমার ফাংশনে পাস করা মানগুলির একটি অ্যারে রয়েছে যা পরবর্তী প্রসেসিংয়ের জন্য আমার সংরক্ষণ করতে হবে। যেহেতু আমি জানি না যে ডেটা প্রক্রিয়া করার সময় হওয়ার আগে আমার ফাংশনটি কতবার ডাকা হবে, তাই আমার একটি গতিশীল স্টোরেজ কাঠামো প্রয়োজন, তাই আমি একটিটি বেছে নিয়েছি std::vector। আমি push_backসমস্ত মানগুলিতে স্বতন্ত্রভাবে স্ট্যান্ডার্ড লুপটি করতে চাই না , এটির মতো কিছু ব্যবহার করে আমি কেবল সমস্তগুলি অনুলিপি করতে পারলে ভাল লাগবে memcpy।
উত্তর:
অ্যারে এবং অ্যারের আকার অর্জনের পরে যদি আপনি ভেক্টরটি তৈরি করতে পারেন তবে আপনি কেবল বলতে পারেন:
std::vector<ValueType> vec(a, a + n);... ধরে aনেওয়া আপনার অ্যারে এবং nএতে থাকা উপাদানগুলির সংখ্যা। অন্যথায়, std::copy()ডাব্লু / resize()কৌশলটি করবে।
memcpy()মানগুলি সরল-পুরাতন ডেটা (পিওডি) প্রকারের না তা আপনি নিশ্চিত না করতে পারলে আমি এ থেকে দূরে থাকতাম ।
এছাড়াও, লক্ষণীয় যে এগুলির কোনওটিই লুপের জন্য সত্যই এড়ানো যায় না - এটি আপনার কোডে দেখতে হবে কিনা তা কেবল একটি প্রশ্ন। ও (এন) রানটাইম পারফরম্যান্স মানগুলি অনুলিপি করার জন্য অনিবার্য।
পরিশেষে, নোট করুন যে সি-স্টাইলের অ্যারেগুলি বেশিরভাগ এসটিএল অ্যালগরিদমের জন্য পুরোপুরি বৈধ ধারক - কাঁচা পয়েন্টারটি সমান begin(), এবং ( ptr + n) এর সমতুল্য end()।
এখানে অনেক উত্তর এসেছে এবং প্রায় সবগুলিই কাজটি সম্পন্ন করবে।
তবে কিছু বিভ্রান্তিকর পরামর্শ আছে!
এখানে বিকল্পগুলি:
vector<int> dataVec;
int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
unsigned dataArraySize = sizeof(dataArray) / sizeof(int);
// Method 1: Copy the array to the vector using back_inserter.
{
copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}
// Method 2: Same as 1 but pre-extend the vector by the size of the array using reserve
{
dataVec.reserve(dataVec.size() + dataArraySize);
copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}
// Method 3: Memcpy
{
dataVec.resize(dataVec.size() + dataArraySize);
memcpy(&dataVec[dataVec.size() - dataArraySize], &dataArray[0], dataArraySize * sizeof(int));
}
// Method 4: vector::insert
{
dataVec.insert(dataVec.end(), &dataArray[0], &dataArray[dataArraySize]);
}
// Method 5: vector + vector
{
vector<int> dataVec2(&dataArray[0], &dataArray[dataArraySize]);
dataVec.insert(dataVec.end(), dataVec2.begin(), dataVec2.end());
}একটি দীর্ঘ গল্পের সংক্ষিপ্ত পদ্ধতি 4 কাটা, ভেক্টর :: সন্নিবেশ ব্যবহার করে বিস্রুতের দৃশ্যের জন্য সেরা।
এখানে কিছু বিষণ্ণ বিবরণ দেওয়া হল:
পদ্ধতি 1 বোঝার জন্য সম্ভবত সবচেয়ে সহজ। অ্যারে থেকে কেবল প্রতিটি উপাদান অনুলিপি করুন এবং এটি ভেক্টরের পিছনে চাপুন। হায়রে, এটা ধীর। যেহেতু একটি লুপ আছে (অনুলিপি ফাংশন দিয়ে বোঝানো), প্রতিটি উপাদান পৃথকভাবে চিকিত্সা করা উচিত; আরে এবং ভেক্টরগুলি সংকীর্ণ ব্লকগুলি এই সত্যের ভিত্তিতে কোনও পারফরম্যান্সের উন্নতি করা যায় না।
পদ্ধতি 2 পদ্ধতি 1 এর প্রস্তাবিত কার্যকারিতা উন্নতি; অ্যারের যোগ করার আগে এটির আকারটি কেবল সংরক্ষণ করুন। বড় অ্যারেগুলির জন্য এটি সহায়তা করতে পারে। তবে এখানে সর্বোত্তম পরামর্শটি কখনই রিজার্ভ ব্যবহার করা উচিত নয় যতক্ষণ না প্রোফাইলিং পরামর্শ দেয় আপনি উন্নতি করতে সক্ষম হতে পারেন (বা আপনার পুনরুক্তিগুলি অবৈধ হতে যাচ্ছে না তা নিশ্চিত করার প্রয়োজন)। বর্জন একমত । ঘটনাক্রমে, আমি দেখতে পেয়েছি যে এই পদ্ধতিটি বেশিরভাগ সময়ই সবচেয়ে ধীরে সম্পাদিত হয়েছিল যদিও আমি বিস্তৃতভাবে ব্যাখ্যা করার জন্য লড়াই করছি যে কেন এটি নিয়মিতভাবে পদ্ধতি 1 এর চেয়ে উল্লেখযোগ্যভাবে ধীর হয় ...
পদ্ধতি 3 হ'ল পুরাতন স্কুল সমাধান - সমস্যাটিতে কিছু সি ফেলে দিন! পিওডি ধরণের জন্য সূক্ষ্ম এবং দ্রুত কাজ করে। এক্ষেত্রে মাইজপি ভেক্টরের সীমানার বাইরে কাজ করে এবং কোনও ভেক্টরকে বলার উপায় নেই যে এর আকার পরিবর্তন হয়েছে। কদর্য সমাধান ছাড়াও (বাইট অনুলিপি করুন!) মনে রাখবেন যে এটি কেবল পিওডি ধরণের জন্য ব্যবহার করা যেতে পারে । আমি এই সমাধানটি কখনই ব্যবহার করব না।
পদ্ধতি 4 যাওয়ার সর্বোত্তম উপায়। এর অর্থ পরিষ্কার, এটি (সাধারণত) দ্রুত এবং এটি কোনও বস্তুর জন্য কাজ করে। এই অ্যাপ্লিকেশনটির জন্য এই পদ্ধতিটি ব্যবহার করার কোনও খারাপ দিক নেই।
পদ্ধতি 5 পদ্ধতি 4 তে একটি সাম্প্রতিক চিহ্ন - অ্যারেটিকে একটি ভেক্টরে অনুলিপি করুন এবং তারপরে এটি যুক্ত করুন। ভাল বিকল্প - সাধারণত দ্রুত-ইশ এবং পরিষ্কার।
অবশেষে, আপনি সচেতন যে আপনি অ্যারের জায়গায় ভেক্টর ব্যবহার করতে পারেন, তাই না? এমনকি যখন কোনও ফাংশন সি-স্টাইলের অ্যারেগুলি প্রত্যাশা করে আপনি ভেক্টরগুলি ব্যবহার করতে পারেন:
vector<char> v(50); // Ensure there's enough space
strcpy(&v[0], "prefer vectors to c arrays");আশা করি সেখানকার কাউকে সাহায্য করবে!
&exprমূল্যায়ন করে না expr, এটি কেবল এটির ঠিকানা গণনা করে। আর পয়েন্টার এক শেষ উপাদান গত পুরোপুরি বৈধ, অত্যধিক।
dataVec.insert(dataVec.end(), dataArray, dataArray + dataArraySize);- আমার কাছে আরও পরিষ্কার appears পদ্ধতি 5 থেকে কোনও কিছুই অর্জন করা যায় না, কেবল বেশ অদক্ষ মনে হয় - যদি না কম্পাইলার আবার ভেক্টরটিকে আবার অনুকূল করতে সক্ষম না করে।
যদি আপনি যা করছেন সবই যদি বিদ্যমান ডেটাটি প্রতিস্থাপন করে তবে আপনি এটি করতে পারেন
std::vector<int> data; // evil global :)
void CopyData(int *newData, size_t count)
{
data.assign(newData, newData + count);
}std :: অনুলিপি যা আপনি খুঁজছেন।
যেহেতু আমি কেবল নিজের উত্তরটি সম্পাদনা করতে পারি, তাই আমি আমার প্রশ্নের অন্যান্য উত্তরগুলি থেকে একটি সম্মিলিত উত্তর দিতে যাচ্ছি। আপনারা যারা উত্তর দিয়েছেন সবাইকে ধন্যবাদ।
এসটিডি :: অনুলিপি ব্যবহার করে , এটি এখনও পটভূমিতে পুনরাবৃত্তি করে তবে আপনার কোডটি টাইপ করতে হবে না।
int foo(int* data, int size)
{
static std::vector<int> my_data; //normally a class variable
std::copy(data, data + size, std::back_inserter(my_data));
return 0;
}নিয়মিত মেমকি ব্যবহার করা হচ্ছে । এটি সম্ভবত প্রাথমিক তথ্য প্রকারের (যেমন ইন্ট্রি) জন্য সবচেয়ে বেশি ব্যবহৃত হয় তবে স্ট্রাক্ট বা ক্লাসের আরও জটিল অ্যারেগুলির জন্য নয়।
vector<int> x(size);
memcpy(&x[0], source, size*sizeof(int));আমি বলি স্মৃতি এড়ানো পয়েন্টার অপারেশনগুলির সাথে ঝামেলা করার কোনও কারণ নেই যদি না আপনার সত্যিই দরকার হয়। এছাড়াও, এটি কেবল পিওডির ধরণের (ইন্টের মতো) জন্য কাজ করবে তবে আপনি যদি এমন ধরণের নির্মাণের প্রয়োজন হয় তবে তা ব্যর্থ হয়।
int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//source
unsigned dataArraySize = sizeof(dataArray) / sizeof(int);
std::vector<int> myvector (dataArraySize );//target
std::copy ( myints, myints+dataArraySize , myvector.begin() );
//myvector now has 1,2,3,...10 :-)myints?
তবুও অন্য একটি উত্তর, যেহেতু ব্যক্তিটি বলেছিল "আমার ফাংশনটি কতবার ডাকা হবে তা আমি জানি না", তাই আপনি ভেক্টরের সন্নিবেশ পদ্ধতিটি ভেক্টরের শেষে মানগুলির অ্যারে যুক্ত করতে ব্যবহার করতে পারেন:
vector<int> x;
void AddValues(int* values, size_t size)
{
x.insert(x.end(), values, values+size);
}আমি এই উপায়টি পছন্দ করি কারণ ভেক্টরের প্রয়োগটি পুনরাবৃত্তকারী টাইপ এবং টাইপের উপর ভিত্তি করে মান সন্নিবেশ করার সর্বোত্তম পদ্ধতির জন্য অনুকূল করতে সক্ষম হওয়া উচিত। আপনি কিছুটা স্টিলের প্রয়োগের উপর জবাব দিচ্ছেন।
আপনার যদি দ্রুততম গতির গ্যারান্টি দেওয়া দরকার এবং আপনি জানেন যে আপনার প্রকারটি একটি পিওডি টাইপ হয় তবে আমি থমাসের উত্তরে পুনরায় আকার দেওয়ার পদ্ধতিটি সুপারিশ করব:
vector<int> x;
void AddValues(int* values, size_t size)
{
size_t old_size(x.size());
x.resize(old_size + size, 0);
memcpy(&x[old_size], values, size * sizeof(int));
}উপরে উপস্থাপিত পদ্ধতিগুলি ছাড়াও, আপনার ভেক্টরটিতে পর্যাপ্ত উপাদান রয়েছে কিনা তা নিশ্চিত করার জন্য আপনাকে অবশ্যই std :: Vector.reserve (), std :: Vector.resize () ব্যবহার করুন বা আকারে ভেক্টরটি তৈরি করতে হবে তা নিশ্চিত করতে হবে এটি আপনার তথ্য রাখা। যদি তা না হয় তবে আপনি স্মৃতিশক্তি নষ্ট করবেন। এটি স্ট্যান্ড :: কপি () বা মেমকি () এর ক্ষেত্রে সত্য।
এটি ভেক্টর.পুশ_ব্যাক () ব্যবহার করার কারণ, আপনি ভেক্টরের শেষটি লিখতে পারবেন না।
ধরে নিচ্ছি আপনি ভেক্টরের আইটেমটি কত বড় তা জানেন:
std::vector<int> myArray;
myArray.resize (item_count, 0);
memcpy (&myArray.front(), source, item_count * sizeof(int));