하드 코딩 된 요소로 std :: vector를 초기화하는 가장 쉬운 방법은 무엇입니까?

배열을 만들고 다음과 같이 초기화 할 수 있습니다.

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

어떻게 std::vector우아하게 만들고 우아하게 초기화합니까?

내가 아는 가장 좋은 방법은 다음과 같습니다.

std::vector<int> ints;

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

더 좋은 방법이 있습니까?

한 가지 방법은 배열을 사용하여 벡터를 초기화하는 것입니다.

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

컴파일러가 C ++ 11을 지원하는 경우 다음을 수행하면됩니다.

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

이것은 4.4 버전 부터 GCC에서 사용할 수 있습니다 . 불행하게도, VC ++ 2010은 이런 점에서 뒤쳐져있는 것 같습니다.

또는 Boost.Assign 라이브러리는 비 매크로 매직을 사용하여 다음을 허용합니다.

#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후드를) 당신이 Yacoby 말한대로 일을 더 나을 것 성능이 중요한 코드 때문에.

가능하다면 현대적인 C ++ [11,14,17, ...] 방식을 사용하십시오 :

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

가변 길이 배열을 반복하거나 사용하는 오래된 방법 sizeof()은 실제로 눈에 끔찍하며 정신적 오버 헤드 측면에서 완전히 필요하지 않습니다. 왝.

C ++ 0x에서는 배열과 동일한 방식으로 수행 할 수 있지만 현재 표준에서는 불가능합니다.

언어 만 지원하면 다음을 사용할 수 있습니다.

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

다른 라이브러리를 추가 할 수 있다면 boost :: assignment를 시도 할 수 있습니다.

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

C ++ 11에서 :

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

부스트 list_of 사용 :

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

기존의 STL :

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

일반 매크로가있는 기존의 STL :

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

벡터 이니셜 라이저 매크로가있는 기존의 STL :

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

방금 $ 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);

그러나 C ++ 0x를 기다릴 수 없습니다. 코드가 Visual Studio에서 컴파일되어야하기 때문에 멈췄습니다. 우우.

C ++ 11 이전 :

방법 1 =>

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

방법 2 =>

 v.push_back(SomeValue);

C ++ 11 이후도 가능합니다

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

로 시작:

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

C ++ 11 컴파일러가없고 boost를 사용하지 않으려는 경우 :

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

C ++ 11 컴파일러가없고 boost를 사용할 수있는 경우 :

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

C ++ 11 컴파일러가있는 경우 :

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

벡터 초기화의 경우-

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

c ++ 11 컴파일러가 있으면 수행 할 수 있습니다.

그렇지 않으면 데이터 배열을 가지고 for 루프를 사용할 수 있습니다.

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

이 외에도 몇 가지 코드를 사용하여 위에서 설명한 다양한 다른 방법이 있습니다. 제 생각에는 이러한 방법은 기억하기 쉽고 빠르게 쓸 수 있습니다.

가장 쉬운 방법은 다음과 같습니다.

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

을 사용하여 자체 솔루션을 빌드 va_arg합니다. 이 솔루션은 C ++ 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;
}

데모

컴파일러가 Variadic 매크로 (대부분의 최신 컴파일러에 해당)를 지원하는 경우 다음 매크로를 사용하여 벡터 초기화를 단일 라이너로 변환 할 수 있습니다.

#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를 가진 my_vector라는 새로운 int 벡터를 생성합니다.

부스트를 사용하고 싶지 않지만 다음과 같은 구문을 즐기고 싶다면

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

C ++ 11에서 :

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

boost :: assign을 사용하여 그렇게 할 수 있습니다.

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

여기에 상세

더 최근의 중복 된 질문이 이 대답 하여 빅토르 SEHR을 . 나를 위해, 그것은 작고 시각적으로 매력적입니다 (값을 '밀어 넣는 것처럼 보입니다') .c ++ 11 또는 타사 모듈이 필요하지 않으며 추가 (쓰기) 변수를 사용하지 않습니다. 아래는 몇 가지 변경 사항으로 사용하는 방법입니다. 나는 미래의 intead에서 vector 및 / 또는 va_arg의 기능을 확장하는 것으로 전환 할 수 있습니다.

// 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)

아래 방법을 사용하여 벡터를 C ++로 초기화 할 수 있습니다.

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 이상에서만 허용됩니다.

여기에는 좋은 대답이 많이 있지만, 이것을 읽기 전에 독자적으로 혼자 도착했기 때문에 어쨌든 여기에 광산을 던질 것이라고 생각했습니다 ...

다음은 컴파일러와 플랫폼에서 보편적으로 작동하는 방법입니다.

객체 모음의 컨테이너로 구조체 또는 클래스를 만듭니다. <<에 대한 연산자 과부하 함수를 정의하십시오.

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

이렇게하면 동적으로 크기가 조정 된 객체 컬렉션을 하나의 깔끔한 라인으로 함수에 전달하고 전달할 수 있습니다!

Boost에 대한 종속성을 만들지 않고 Boost :: assign과 동일한 일반적인 순서로 무언가를 원하면 다음과 같이 모호하게 유사합니다.

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

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>

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

배열이 다음과 같은 경우 :

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 

테스트를 작성할 때 변수를 정의하지 않고 벡터 인라인을 작성하는 것이 매우 편리합니다. 예를 들면 다음과 같습니다.

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

관련 벡터를 빠른 문장으로 완벽하게 준비하려면 (예 : 다른 함수로 즉시 전달) 다음을 사용할 수 있습니다.

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

decltype에주의해야하지만 첫 번째 값이 원하는 값인지 분명히 확인하십시오.

벡터를 하드 코딩하는 방법에는 여러 가지가 있으며 몇 가지 방법을 공유합니다.

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()); 

"STL 벡터를 만들고 위와 같이 초기화하는 방법은 무엇입니까? 최소한의 타이핑 노력으로 가장 좋은 방법은 무엇입니까?"

내장 배열을 초기화 할 때 벡터를 초기화하는 가장 쉬운 방법 은 C ++ 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);

ivec는 Assigning (labeled statement)이 실행 된 후 크기가 3 요소입니다.

B. Stroustrup 은 Prog의 C ++ 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

가장 간단하고 인체 공학적인 방법 (C ++ 11 이상) :

auto my_ints = {1,2,3};

자신의 수업에 넣고 싶다면 :

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