হার্ডকডযুক্ত উপাদান দিয়ে স্টাড :: ভেক্টর শুরু করার সহজতম উপায় কী?

Question

আমি একটি অ্যারে তৈরি করতে এবং এটি এর মতো সূচনা করতে পারি:

int a[] = {10, 20, 30};

আমি কীভাবে std::vectorএটি তৈরি করতে পারি এবং একইভাবে মার্জিত এটি আরম্ভ করব?

আমার জানা সবচেয়ে ভাল উপায় হ'ল:

std::vector<int> ints;

ints.push_back(10);
ints.push_back(20);
ints.push_back(30);

একটি ভাল উপায় আছে কি?

Comments

আপনি যদি আরম্ভের পরে আর্টসের আকার পরিবর্তন করতে না চান, তবে tr1 অ্যারে ব্যবহার করে বিবেচনা করুন।

— zr।

@ জেআর, আপনারা আমাকে কৌতূহলী করেছেন ... আমার যদি নির্দিষ্ট আকারের প্রয়োজন হয়, তবে আমি কী তাদের পুরানো অ্যারেগুলি ব্যবহার করতে পারি না? এখনই tr1 অ্যারে এ খুঁজছি ...

— Agnel Kurian

tr1::arrayদরকারী কারণ সাধারণ অ্যারেগুলি এসটিএল পাত্রে ইন্টারফেস সরবরাহ করে না

— ম্যানুয়েল

এটিকে পরিষ্কারভাবে একটি C ++ 03 টি প্রশ্ন তৈরি করতে শিরোনাম পরিবর্তন হয়েছে। নতুন স্ট্যান্ডার্ড সি ++ দিয়ে বোঝার জন্য সমস্ত উত্তরগুলি স্থির করে এবং ঠিক করার চেয়ে এটি আরও সহজ মনে হয়েছিল।

— টেড

একে তালিকার সূচনা বলে ।

— অ্যালান ডকিন্স

Answer 1

একটি পদ্ধতি ভেক্টর আরম্ভ করার জন্য অ্যারে ব্যবহার করা হবে

static const int arr[] = {16,2,77,29};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

Comments

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

— ইয়াকবি

আমি এটিকে অগ্রাহ্য করি নি, তবে আমি প্রলুব্ধ হয়েছি। মূলত কারণ এটি আপনাকে প্রথম দিকে আরম্ভ করা অ্যারে ব্যবহার করে প্রায় কিছুই বাঁচায়। তবে এটি আসলে সি ++ এর দোষ, আপনার নয়।

— টেড

ভেক্টর ভেক্টর সংজ্ঞায়নের সময় আপনি কেন এই পরামিতিগুলি ব্যবহার করছেন তা ব্যাখ্যা করতে পারেন।

— DomX23

সাইজফ (অ্যারে) কয়েকটি ব্যতিক্রমগুলির মধ্যে একটি যা অ্যারের উপাদানগুলির মোট আকার এবং অ্যার পয়েন্টার মাত্রা নয় প্রাপ্ত করতে দেয়। সুতরাং মূলত তিনি ভেক্টরটি ব্যবহার করছেন (পয়েন্টার_ টু_ফের্স্ট_এলিমেন্ট, পয়েন্টার_ টু_ফার্স্ট_ইলিমেন্ট + সাইজ_ইন_বাইটস_ফ_এইচ_হোল_আরয়ে / সাইজ_ফোন_এইলেমেন্ট) যা: ভেক্টর (পয়েন্টার_ টু_ফিসার_সংশ্লিষ্ট, পয়েন্টার_ফরিনাল_ফিনাল_ইলেটমেন্ট)। প্রকারটি ইতিমধ্যে <int> দিয়ে দেওয়া হয়েছে, সুতরাং ভেক্টর জানেন যে একটি উপাদান কত। মনে রাখবেন যে পুনরাবৃত্তকারীকে পয়েন্টার হিসাবে বিবেচনা করা যেতে পারে তাই আপনি মূলত ভেক্টর (পুনরুক্তি শুরু, পুনরুদ্ধারকারী) নির্মাণকারী ব্যবহার করছেন

— জনি পলিং

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

— ডার্ক ওয়ান্ডারার

Answer 2

যদি আপনার সংকলক সি ++ 11 সমর্থন করে তবে আপনি কেবল তা করতে পারেন:

std::vector<int> v = {1, 2, 3, 4};

এটি জিসিসিতে সংস্করণ ৪.৪ হিসাবে উপলব্ধ । দুর্ভাগ্যক্রমে, ভিসি ++ ২০১০ এই ক্ষেত্রে পিছিয়ে রয়েছে বলে মনে হচ্ছে।

বিকল্পভাবে, বুস্ট.আসাইন লাইব্রেরি নিম্নলিখিতগুলির অনুমতি দিতে নন-ম্যাক্রো যাদু ব্যবহার করে:

#include <boost/assign/list_of.hpp>
...
std::vector<int> v = boost::assign::list_of(1)(2)(3)(4);

বা:

#include <boost/assign/std/vector.hpp>
using namespace boost::assign;
...
std::vector<int> v;
v += 1, 2, 3, 4;

তবে মনে রাখবেন এটির কিছুটা ওভারহেড রয়েছে (মূলত, হুডের নীচে list_ofএকটি নির্মাণ std::dequeকরে) সুতরাং পারফরম্যান্স-সমালোচনামূলক কোডের জন্য আপনি ইয়াকোবি যেমন বলেছেন তেমন করাই ভাল।

Comments

যেহেতু ভেক্টরগুলি স্ব-আকারের হয়, তাই এটিও খালি হিসাবে শুরু করা ঠিক হবে? কন্সট্রাকটর মত: this->vect = {};?

— আজুরস্পট

@ আজুরস্পট আপনি কেবল এটি সূচনা করতে পারেন, এবং এটি খালি হবে:std::vector<T> vector;

— লুক

যদি কারও সম্পর্কে কৌতূহলী হতে পারে তবে std::vector<int> v = {1, 2, 3, 4};ভেক্টরকে initializer list constructorএই ধরণের সূচনা করার জন্য ডাকা হবে, তার ডকটি C++ 11বিভাগে পাওয়া যাবে ।

— সিমো

Answer 3

যদি আপনি পারেন তবে আধুনিক সি ++ [11,14,17, ...] উপায়টি ব্যবহার করুন:

std::vector<int> vec = {10,20,30};

পরিবর্তনশীল দৈর্ঘ্যের অ্যারের উপর লুপিং বা ব্যবহারের পুরানো উপায়টি sizeof()চোখের কাছে সত্যই ভয়ঙ্কর এবং মানসিক ওভারহেডের ক্ষেত্রে সম্পূর্ণ অপ্রয়োজনীয়। ইশ।

Comments

ন্যায়সঙ্গতভাবে, এটি মূলত একটি C ++ 03 প্রশ্ন ছিল তবে আমি আশা করি যে লোক / সংস্থাগুলি নতুন মান গ্রহণ করবে। সি ++ এর জন্য স্ট্যান্ডার্ড লাইব্রেরিতে আইজেন এবং বুস্টের মতো উপলব্ধ একটি পরিবর্তনশীল-দৈর্ঘ্যের অ্যারে (ভিএলএ) বাস্তবায়ন প্রয়োজন।

— অ্যাডাম এরিকসন

দুর্ভাগ্যক্রমে, এই পদ্ধতির কিছু ক্ষেত্রে যেমন সমস্যা রয়েছে যেমন: ওপেন- std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1467 । ইশ।

— অরবিতের হালকাত্বের রেস

যদি "একই ধরণের কোনও অবজেক্ট থেকে সামগ্রিকের তালিকা-সূচনাকরণ" আপনার জিনিস হয় তবে সম্ভবত আপনার কোডবেসে আরও বড় সমস্যা রয়েছে ... আমি কোনও অ্যাপ্লিকেশন নিয়ে ভাবতে পারি না যেখানে এটি ডিবাগিংয়ের সমস্যাগুলিকে ন্যায্যতা দেয়।

— অ্যাডাম এরিকসন

Answer 4

C ++ 0x এ আপনি ঠিক একই পদ্ধতিতে এটি করতে সক্ষম হবেন যা আপনি অ্যারের সাথে করেছিলেন তবে বর্তমান মান হিসাবে নয়।

কেবলমাত্র ভাষা সমর্থন দিয়ে আপনি ব্যবহার করতে পারেন:

int tmp[] = { 10, 20, 30 };
std::vector<int> v( tmp, tmp+3 ); // use some utility to avoid hardcoding the size here

আপনি যদি অন্যান্য লাইব্রেরি যুক্ত করতে পারেন তবে :: বরাদ্দকরণের চেষ্টা করতে পারেন:

vector<int> v = list_of(10)(20)(30);

একটি অ্যারের আকারের হার্ডকোডিং এড়াতে:

// option 1, typesafe, not a compile time constant
template <typename T, std::size_t N>
inline std::size_t size_of_array( T (&)[N] ) {
   return N;
}
// option 2, not typesafe, compile time constant
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

// option 3, typesafe, compile time constant
template <typename T, std::size_t N>
char (&sizeof_array( T(&)[N] ))[N];    // declared, undefined
#define ARRAY_SIZE(x) sizeof(sizeof_array(x))

Comments

অবশ্যই আমি ডাউনভিট করি নি তবে আমার যেভাবেই হোক একটি প্রশ্ন আছে: অ্যারের আকার কখনই একটি সংকলন সময় স্থির হয় না? উদাহরণস্বরূপ, কোন ক্ষেত্রে আপনি দ্বিতীয় স্নিপেটে তৃতীয়টির বিপরীতে প্রথম সমাধানটি ব্যবহার করবেন?

— ম্যানুয়েল

@ ম্যানুয়েল, অ্যারের আকারটি প্রকারের একটি অংশ এবং এর মতো এটি একটি সংকলনের সময় ধ্রুবক। এখন, বিকল্প 1 কোনও ফাংশনের রিটার্ন মান হিসাবে সংকলিত সময় ধ্রুবক 'N' ব্যবহার করে। কোনও ফাংশনটির প্রত্যাবর্তন কোনও সংকলনের সময় নয়, তবে রানটাইম মান হয়, এমনকি যদি এটি সম্ভবত কলের স্থানে ধ্রুবক মান হিসাবে অন্তর্ভুক্ত হয়। পার্থক্যটি হ'ল আপনি পারবেন না: int another[size_of_array(array)]যখন আপনি করতে পারেন int another[ARRAY_SIZE(array)]।

— ডেভিড রদ্রিগেজ - ড্রিবিস

3 বিকল্পে: "ঘোষিত, অপরিজ্ঞাত" দিয়ে আপনি কী বোঝাতে চেয়েছেন তা আমি সত্যিই পাই না? তাহলে ভেরিয়েবল অতিরিক্ত মেমরি নেবে না?

— To1ne

@ To1ne এটি একটি ফাংশন ডিক্লেয়ারেশন, ভেরিয়েবল নয়। এটির সংজ্ঞা দেওয়ার কারণ বা sizeofসংজ্ঞাটি হ'ল আমরা প্রকৃতপক্ষে অভিব্যক্তি ছাড়া অন্য কোনও কিছুর জন্য ফাংশনটি চাই না যার সংজ্ঞা প্রয়োজন হয় না। আপনি প্রকৃতপক্ষে কোনও সংজ্ঞা দিতে পারেন, এটি সঠিকভাবে করার জন্য একটি অ্যারের স্থির বরাদ্দ প্রয়োজন এবং এটির একটি রেফারেন্স ফিরিয়ে আনতে হবে এবং পরবর্তী প্রশ্নটি অ্যারের মান হিসাবে কী বোঝাবে? (আরও মনে রাখবেন যে এটি ফাংশনের ইনস্ট্যানটিশনের প্রতি টাইপ / আকারের সংমিশ্রণের জন্য একটি অ্যারের অর্থ!) যেহেতু এটির জন্য কোনও বুদ্ধিমান ব্যবহার নেই, আমি বরং এটি এড়াতে চাই।

— ডেভিড রদ্রিগেজ - শুক্রবার 20'12

@ এমএইচডি: আপনি ভাষায় খালি অ্যারে তৈরি করতে পারবেন না। 'int আরআর [0] = {};' বৈধ সি ++ কোড নয়। তবে আপনি ঠিক বলেছেন যে আপনি যদি খালি ভেক্টর এবং একটি খালি খালি ভেক্টর শুরু করতে চান তবে আপনাকে বিভিন্ন কনস্ট্রাক্ট ব্যবহার করতে হবে। যেহেতু সি ++ 11 এটি ইস্যু নয় কারণ আপনি

— আরম্ভকারী

Answer 5

সি ++ 11 এ:

#include <vector>
using std::vector;
...
vector<int> vec1 { 10, 20, 30 };
// or
vector<int> vec2 = { 10, 20, 30 };

বুস্টের তালিকা_ ব্যবহার করে:

#include <vector>
#include <boost/assign/list_of.hpp>
using std::vector;
...
vector<int> vec = boost::assign::list_of(10)(20)(30);

বুস্ট অ্যাসাইন ব্যবহার করুন:

#include <vector>
#include <boost/assign/std/vector.hpp>
using std::vector;
...
vector<int> vec;
vec += 10, 20, 30;

প্রচলিত এসটিএল:

#include <vector>
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

জেনেরিক ম্যাক্রো সহ প্রচলিত এসটিএল:

#include <vector>
#define ARRAY_SIZE(ar) (sizeof(ar) / sizeof(ar[0])
#define ARRAY_END(ar) (ar + ARRAY_SIZE(ar))
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, ARRAY_END(arr));

একটি ভেক্টর আরম্ভকারী ম্যাক্রো সহ প্রচলিত এসটিএল:

#include <vector>
#define INIT_FROM_ARRAY(ar) (ar, ar + sizeof(ar) / sizeof(ar[0])
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec INIT_FROM_ARRAY(arr);

Comments

সি ++ 11 এছাড়াও সমর্থন করে std::beginএবং std::endঅ্যারের জন্য, তাই কোনও ভেক্টরও এর মতো আরম্ভ করা যেতে পারে static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr));।

— জায়েজে

Answer 6

ভেবেছিলাম আমি আমার 0.02 ডলারে টস করব। আমি এই ঘোষণার ঝোঁক:

template< typename T, size_t N >
std::vector<T> makeVector( const T (&data)[N] )
{
    return std::vector<T>(data, data+N);
}

ইউটিলিটি শিরোনামে কোথাও এবং তারপরে যা যা প্রয়োজন তা হ'ল:

const double values[] = { 2.0, 1.0, 42.0, -7 };
std::vector<double> array = makeVector(values);

তবে আমি সি ++ 0x এর জন্য অপেক্ষা করতে পারি না। আমি আটকেছি কারণ আমার কোডটি অবশ্যই ভিজ্যুয়াল স্টুডিওতে সংকলন করতে পারে। বু।

Comments

এই কৌশলটি টাইপ আকারের সাথে কোনও অ্যারে গ্রহণ করতে কোনও ক্রিয়াকে ওভারলোড করতেও ব্যবহার করা যেতে পারে।

— আন্দ্রেস রিওফ্রিও

আপনি const T (&data)[N]অংশটি ব্যাখ্যা করতে পারেন ? আপনার কলটিতে অ্যারের আকারটি কীভাবে কেটে নেওয়া হয় makeVector(values)?

— প্যাট্রিক

Answer 7

সি ++ এর আগে:

পদ্ধতি 1 =>

vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));
vector<int>v;

পদ্ধতি 2 =>

 v.push_back(SomeValue);

নীচে সি ++ 11 পরেও সম্ভব

vector<int>v = {1, 3, 5, 7};

Answer 8

দিয়ে শুরু:

int a[] = {10, 20, 30}; //i'm assuming a is just a placeholder

আপনার যদি সি ++ 11 সংকলক না থাকে এবং আপনি বুস্টটি ব্যবহার করতে চান না:

const int a[] = {10, 20, 30};
const std::vector<int> ints(a,a+sizeof(a)/sizeof(int)); //make it const if you can

আপনার যদি সি ++ 11 সংকলক না থাকে এবং বুস্টটি ব্যবহার করতে পারেন:

#include <boost/assign.hpp>
const std::vector<int> ints = boost::assign::list_of(10)(20)(30);

আপনার যদি সি ++ 11 সংকলক থাকে:

const std::vector<int> ints = {10,20,30};

Answer 9

ভেক্টর আরম্ভের জন্য -

vector<int> v = {10,20,30}

আপনার সি ++ 11 সংকলক থাকলে করা যায়।

অন্যথায়, আপনি ডেটার একটি অ্যারে রাখতে পারেন এবং তারপরে লুপের জন্য একটি ব্যবহার করতে পারেন।

int array[] = {10,20,30}
for(unsigned int i=0; i<sizeof(array)/sizeof(array[0]); i++)
{
     v.push_back(array[i]);
}

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

Answer 10

এটি করার সবচেয়ে সহজ উপায় হ'ল:

vector<int> ints = {10, 20, 30};

Comments

কোন সংকলক? আপনি কি এখানে C ++ 11 ব্যবহার করছেন?

— অগ্নেল কুরিয়ান

g ++ 4.6.3 -std = c ++ 0x সহ।

— পল বাল্টেস্কু

Answer 11

আমি নিজের সমাধান ব্যবহার করে তৈরি করি va_arg। এই সমাধানটি সি ++ 98 অনুসারী।

#include <cstdarg>
#include <iostream>
#include <vector>

template <typename T>
std::vector<T> initVector (int len, ...)
{
  std::vector<T> v;
  va_list vl;
  va_start(vl, len);
  for (int i = 0; i < len; ++i)
    v.push_back(va_arg(vl, T));
  va_end(vl);
  return v;
}

int main ()
{
  std::vector<int> v = initVector<int> (7,702,422,631,834,892,104,772);
  for (std::vector<int>::const_iterator it = v.begin() ; it != v.end(); ++it)
    std::cout << *it << std::endl;
  return 0;
}

ডেমো

Answer 12

যদি আপনার সংকলকটি ভেরিয়াদিক ম্যাক্রোগুলিকে সমর্থন করে (যা বেশিরভাগ আধুনিক সংকলকগুলির ক্ষেত্রে সত্য) তবে আপনি ভেক্টর আরম্ভকরণটিকে এক-লাইনারে পরিণত করতে নিম্নলিখিত ম্যাক্রোটি ব্যবহার করতে পারেন:

#define INIT_VECTOR(type, name, ...) \
static const type name##_a[] = __VA_ARGS__; \
vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))

এই ম্যাক্রোর সাহায্যে আপনি এই জাতীয় কোড সহ একটি প্রাথমিক ভেক্টর সংজ্ঞায়িত করতে পারেন:

INIT_VECTOR(int, my_vector, {1, 2, 3, 4});

এটি 1, 2, 3, 4 উপাদানগুলির সাথে মাই_ভেেক্টর নামে একটি নতুন ভেক্টর তৈরি করবে।

Answer 13

আপনি যদি বুস্ট ব্যবহার করতে না চান তবে সিনট্যাক্সের মতো উপভোগ করতে চান

std::vector<int> v;
v+=1,2,3,4,5;

শুধু কোড এই অংশ অন্তর্ভুক্ত

template <class T> class vector_inserter{
public:
    std::vector<T>& v;
    vector_inserter(std::vector<T>& v):v(v){}
    vector_inserter& operator,(const T& val){v.push_back(val);return *this;}
};
template <class T> vector_inserter<T> operator+=(std::vector<T>& v,const T& x){
    return vector_inserter<T>(v),x;
}

Comments

আমি এই কোডটি কীভাবে ব্যবহার করব তা নির্ধারণ করতে সক্ষম হয়েছি না তবে এটি আকর্ষণীয় দেখাচ্ছে interesting

— ড্যানিয়েল বাকমাস্টার

এটা উপরের মতামতের একটি মত বলেছেন। মাত্র ওভারলোডিং + = এবং কমা অপারেটর। স্পষ্টতার জন্য ((((v+=1),2),3),4),5) প্রথম বন্ধনী রেখে: এটি এইভাবে কাজ করে: প্রথমে vector<T> += Tকোনও ভেক্টর_ইনসেটরকে কল করতে দেয় viযা আসল ভেক্টরকে এনপ্যাপুলেট করে তারপরে vi,Tটি যুক্ত করতে পারে মূল ভেক্টরকে যা viencapsulate করে এবং এটি স্বত্বে ফিরে আসে যাতে আমরা vi,Tআবার করতে পারি ।

— পিটি ওংমংকোকুলুল

এই কোডটি জিসিসি ৪.২.১-তে সঠিকভাবে কাজ করেনি বলে আমি মনে করি কারণ স্থানীয় ভেরিয়েবলের ভিতরে + = অপারেটরের রেফারেন্স ফিরে আসার কারণে তবে ধারণাটি বহিরাগত। আমি কোড সম্পাদনা করেছি এবং সেখানে আরও একটি অনুলিপি নির্মাণকারী উপস্থিত রয়েছে। প্রবাহ এখন -> + = -> কর্টর -> কমা -> অনুলিপি -> দত্ত -> কমা ...... -> কমা -> ডটর।

— ইয়েভেন

আমি সম্ভবত + = এর পরিবর্তে << ওভারলোড করেছি। কমপক্ষে << এর বিট শিফট এবং

— কোট

Answer 14

সি ++ 11 এ:

static const int a[] = {10, 20, 30};
vector<int> vec (begin(a), end(a));

Comments

আপনি যদি ইতিমধ্যে সি ++ 11 ব্যবহার করেন তবে আপনি সরাসরি পদ্ধতির দিকে যেতে পারেন - vector<int> arr = {10, 20, 30};।

— বার্নহার্ড বার্কার

আসলে আমার একটি ইনকামিং ইনট [] (কিছু সি লিব) ছিল এবং আমি একটি ভেক্টর (সি ++ লিব) pushোকাতে চাই। এই উত্তরটি সাহায্য করেছে, বাকিরা তা করেনি ;-)

— নীহারিকা

Answer 15

আপনি বুস্ট :: অ্যাসাইন্ট ব্যবহার করে এটি করতে পারেন।

vector<int> values;  
values += 1,2,3,4,5,6,7,8,9;

বিস্তারিত এখানে

Comments

অপারেটর ওভারলোডিং অপব্যবহারের খারাপ পরিস্থিতি আমি বেশিদিন দেখিনি। কি +=এটা আছে .. 1,2,3,4 সেখানে ট্যাক মূল্যবোধের শেষ, অথবা যোগ 1 MATLAB- এই উচিত মত 3 য় উপাদানে 2nd উপাদান থেকে 3 1 ম উপাদান, 2 (সিনট্যাক্স যেমন ভাষাগুলির মতো)

— বোলোবোলো

Answer 16

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

---

// Based on answer by "Viktor Sehr" on Stack Overflow
// https://stackoverflow.com/a/8907356
//
template <typename T>
class mkvec {
public:
    typedef mkvec<T> my_type;
    my_type& operator<< (const T& val) {
        data_.push_back(val);
        return *this;
    }
    my_type& operator<< (const std::vector<T>& inVector) {
        this->data_.reserve(this->data_.size() + inVector.size());
        this->data_.insert(this->data_.end(), inVector.begin(), inVector.end());
        return *this;
    }
    operator std::vector<T>() const {
        return data_;
    }
private:
    std::vector<T> data_;
};

std::vector<int32_t>    vec1;
std::vector<int32_t>    vec2;

vec1 = mkvec<int32_t>() << 5 << 8 << 19 << 79;  
// vec1 = (5,8,19,79)
vec2 = mkvec<int32_t>() << 1 << 2 << 3 << vec1 << 10 << 11 << 12;  
// vec2 = (1,2,3,5,8,19,79,10,11,12)

Answer 17

সি ++ তে ভেক্টর আরম্ভ করার জন্য নীচের পদ্ধতিগুলি ব্যবহার করা যেতে পারে।

1. int arr[] = {1, 3, 5, 6}; vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));

2. vector<int>v; v.push_back(1); v.push_back(2); v.push_back(3); ইত্যাদি

3. vector<int>v = {1, 3, 5, 7};

তৃতীয়টি কেবলমাত্র C ++ 11 এর পরে অনুমোদিত।

Answer 18

এখানে অনেক ভাল উত্তর রয়েছে, তবে যেহেতু আমি স্বাধীনভাবে এটি পড়ার আগে আমার নিজের কাছে এসেছি, আমি বুঝতে পেরেছি যেভাবেই হোক আমার এখানে টস আপ ...

এখানে একটি পদ্ধতি যা আমি এর জন্য ব্যবহার করছি যা সংকলক এবং প্ল্যাটফর্ম জুড়ে সর্বজনীনভাবে কাজ করবে:

আপনার অবজেক্টগুলির সংগ্রহের জন্য একটি ধারক বা শ্রেণি তৈরি করুন। << জন্য অপারেটর ওভারলোড ফাংশনটি সংজ্ঞায়িত করুন।

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

আপনি আপনার ফাংশনগুলি প্যারামিটার হিসাবে গ্রহণ করতে পারেন, যেমন:

someFunc( MyObjectList &objects );

তারপরে, আপনি এই ফাংশনটি কল করতে পারেন, এটির মতো:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

এইভাবে, আপনি একটি একক পরিষ্কার লাইনে কোনও ক্রিয়াকলাপে গতিশীল আকারের অবজেক্টগুলি সংগ্রহ এবং পাস করতে পারেন!

Answer 19

বুস্টের উপর নির্ভরতা না তৈরি করে আপনি যদি বুস্ট :: অর্পণ হিসাবে একই সাধারণ ক্রমে কিছু চান তবে নিম্নলিখিতটি অন্তত অস্পষ্টভাবে অনুরূপ:

template<class T>
class make_vector {
    std::vector<T> data;
public:
    make_vector(T const &val) { 
        data.push_back(val);
    }

    make_vector<T> &operator,(T const &t) {
        data.push_back(t);
        return *this;
    }

    operator std::vector<T>() { return data; }
};

template<class T> 
make_vector<T> makeVect(T const &t) { 
    return make_vector<T>(t);
}

যদিও আমি এটির সিনট্যাক্সটি পরিষ্কার করার জন্য চাইছি তবুও এটি বিশেষত ভয়াবহ নয়:

std::vector<int> x = (makeVect(1), 2, 3, 4);

Answer 20

typedef std::vector<int> arr;

arr a {10, 20, 30};       // This would be how you initialize while defining

ব্যবহার সংকলন করতে:

clang++ -std=c++11 -stdlib=libc++  <filename.cpp>

Comments

প্রশ্নে C ++ 03 (11 নয়)

— মাইকে পি

আমি মনে করি যে আমি এটির উত্তর দেওয়ার সময় এটি 03 টি নির্দিষ্ট করে নি। পুরোপুরি মনে রাখবেন না। তবে, দ্রুত সমাধানের সন্ধান করা কারও পক্ষে এটি একটি দরকারী উত্তর।

— shaveenk

Answer 21

// Before C++11
// I used following methods:

// 1.
int A[] = {10, 20, 30};                              // original array A

unsigned sizeOfA = sizeof(A)/sizeof(A[0]);           // calculate the number of elements

                                                     // declare vector vArrayA,
std::vector<int> vArrayA(sizeOfA);                   // make room for all
                                                     // array A integers
                                                     // and initialize them to 0 

for(unsigned i=0; i<sizeOfA; i++)
    vArrayA[i] = A[i];                               // initialize vector vArrayA


//2.
int B[] = {40, 50, 60, 70};                          // original array B

std::vector<int> vArrayB;                            // declare vector vArrayB
for (unsigned i=0; i<sizeof(B)/sizeof(B[0]); i++)
    vArrayB.push_back(B[i]);                         // initialize vArrayB

//3.
int C[] = {1, 2, 3, 4};                              // original array C

std::vector<int> vArrayC;                            // create an empty vector vArrayC
vArrayC.resize(sizeof(C)/sizeof(C[0]));              // enlarging the number of 
                                                     // contained elements
for (unsigned i=0; i<sizeof(C)/sizeof(C[0]); i++)
     vArrayC.at(i) = C[i];                           // initialize vArrayC


// A Note:
// Above methods will work well for complex arrays
// with structures as its elements.

Answer 22

অ্যারেটি যদি হয়:

int arr[] = {1, 2, 3};
int len = (sizeof(arr)/sizeof(arr[0])); // finding length of array
vector < int > v;
std:: v.assign(arr, arr+len); // assigning elements from array to vector 

Answer 23

পরীক্ষা লেখার সময় ভেরিয়েবল সংজ্ঞায়িত না করে ভেক্টর ইনলাইন তৈরি করা বেশ সুবিধাজনক, উদাহরণস্বরূপ:

assert(MyFunction() == std::vector<int>{1, 3, 4}); // <- this.

Answer 24

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

#define VECTOR(first,...) \
   ([](){ \
   static const decltype(first) arr[] = { first,__VA_ARGS__ }; \
   std::vector<decltype(first)> ret(arr, arr + sizeof(arr) / sizeof(*arr)); \
   return ret;})()

উদাহরণ ফাংশন

template<typename T>
void test(std::vector<T>& values)
{
    for(T value : values)
        std::cout<<value<<std::endl;
}

উদাহরণস্বরূপ ব্যবহার

test(VECTOR(1.2f,2,3,4,5,6));

যদিও ডিক্লাইপ সম্পর্কে সতর্ক থাকুন তবে নিশ্চিত হন যে প্রথম মানটি আপনি কী চান তা স্পষ্ট।

Answer 25

"আমি কীভাবে একটি এসটিএল ভেক্টর তৈরি করব এবং উপরের মতো এটি আরম্ভ করব? ন্যূনতম টাইপিংয়ের চেষ্টা করে কী করার সর্বোত্তম উপায়?"

আপনি নিজের অন্তর্নির্মিত অ্যারেটি আরম্ভ করার সাথে সাথে ভেক্টরকে আরম্ভ করার সহজতম উপায়টি একটি ইনিশিয়ালাইজার তালিকা ব্যবহার করছে যা সি ++ 11 এ চালু হয়েছিল ।

// Initializing a vector that holds 2 elements of type int.
Initializing:
std::vector<int> ivec = {10, 20};


// The push_back function is more of a form of assignment with the exception of course
//that it doesn't obliterate the value of the object it's being called on.
Assigning
ivec.push_back(30);

অ্যাসাইনিং (লেবেলযুক্ত বিবৃতি) কার্যকর করার পরে আইভেক আকারে 3 টি উপাদান।

Comments

অনুরূপ লাইনে, আমি মানচিত্রটি শুরু করার চেষ্টা করছি, স্ট্যান্ড :: ম্যাপ <ইন্ট, বুল> ক্যাটিনফো = {{1, ভুয়া}}; তবে তারপরে এই ত্রুটিটি ত্রুটিটি পান: সি ++ 98 'ক্যাটিনফো' অবশ্যই কনস্ট্রাক্টরের দ্বারা শুরু করা উচিত, '{...}' দ্বারা নয়

— পিডিকে

Answer 26

বি। স্ট্রস্ট্রপ প্রগরের সি ++ 11 সংস্করণে 464 পৃষ্ঠাতে 16.2.10 পৃষ্ঠায় চ্যানেল অপারেশন করার একটি দুর্দান্ত উপায় বর্ণনা করেছেন । ল্যাঙ। যেখানে কোনও ফাংশন একটি রেফারেন্স দেয়, এখানে কোনও ভেক্টরে পরিবর্তিত। এইভাবে আপনি পছন্দ করতে পারেন v.pb(1).pb(2).pb(3);তবে এই জাতীয় ছোট লাভের জন্য খুব বেশি কাজ হতে পারে।

#include <iostream>
#include <vector>

template<typename T>
class chain
{
private:
    std::vector<T> _v;
public:
    chain& pb(T a) {
        _v.push_back(a);
        return *this;
    };
    std::vector<T> get() { return _v; };
};

using namespace std;

int main(int argc, char const *argv[])
{
    chain<int> v{};

    v.pb(1).pb(2).pb(3);

    for (auto& i : v.get()) {
        cout << i << endl;
    }

    return 0;
}

1
2
3

Comments

: Armadillo গ্রন্থাগার ম্যাট্রিক্স initialisation জন্য এই আছে কিন্তু একটি নামে ফাংশন পরিবর্তে << অপারেটর ব্যবহার arma.sourceforge.net/docs.html#element_initialisation

— Agnel Kurian

Answer 27

ভেক্টরকে হার্ডকোড করার বিভিন্ন উপায় রয়েছে, আমি কয়েকটি উপায় ভাগ করব:

1. একে একে মানকে ঠেলে দিয়ে শুরু করা

// Create an empty vector 
    vector<int> vect;  

    vect.push_back(10); 
    vect.push_back(20); 
    vect.push_back(30); 

2. অ্যারের মতো শুরু করা হচ্ছে

vector<int> vect{ 10, 20, 30 };

3. একটি অ্যারে থেকে শুরু করা হচ্ছে

    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 

4. অন্য ভেক্টর থেকে শুরু

    vector<int> vect1{ 10, 20, 30 }; 

    vector<int> vect2(vect1.begin(), vect1.end()); 

Answer 28

সবচেয়ে সহজ, আরও অ্যারগোনমিক উপায় (সি ++ 11 বা তার পরে):

auto my_ints = {1,2,3};

Answer 29

আপনি যদি এটি নিজের ক্লাসে রাখতে চান তবে:

#include <initializer_list>
Vector<Type>::Vector(std::initializer_list<Type> init_list) : _size(init_list.size()),
_capacity(_size),
_data(new Type[_size])
{
    int idx = 0;
    for (auto it = init_list.begin(); it != init_list.end(); ++it)
        _data[idx++] = *it;
}