Cách dễ nhất để khởi tạo một std :: vector với các phần tử được mã hóa cứng là gì?

Tôi có thể tạo một mảng và khởi tạo nó như thế này:

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

Làm thế nào để tôi tạo std::vectorvà khởi tạo nó thanh lịch tương tự?

Cách tốt nhất tôi biết là:

std::vector<int> ints;

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

Có cách nào tốt hơn?

Một phương pháp sẽ là sử dụng mảng để khởi tạo vectơ

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

Nếu trình biên dịch của bạn hỗ trợ C ++ 11, bạn chỉ cần làm:

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

Điều này có sẵn trong GCC kể từ phiên bản 4.4 . Thật không may, VC ++ 2010 dường như bị tụt lại phía sau về mặt này.

Ngoài ra, thư viện Boost.Assign sử dụng phép thuật phi vĩ mô để cho phép những điều sau đây:

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

Hoặc là:

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

Nhưng hãy nhớ rằng điều này có một số chi phí chung (về cơ bản, list_ofxây dựng một phần std::dequedưới) vì vậy đối với mã quan trọng về hiệu năng, bạn nên làm tốt hơn như Yacoby nói.

Nếu bạn có thể, hãy sử dụng cách hiện đại C ++ [11,14,17, ...]:

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

Cách thức cũ để lặp lại một mảng có độ dài thay đổi hoặc sử dụng sizeof()thực sự khủng khiếp trên mắt và hoàn toàn không cần thiết về mặt tinh thần. Kinh quá.

Trong C ++ 0x, bạn sẽ có thể làm điều đó giống như cách bạn đã làm với một mảng, nhưng không phải trong tiêu chuẩn hiện tại.

Chỉ với hỗ trợ ngôn ngữ, bạn có thể sử dụng:

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

Nếu bạn có thể thêm các thư viện khác, bạn có thể thử boost :: gán:

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

Để tránh mã hóa kích thước của một mảng:

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

Trong C ++ 11:

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

Sử dụng boost list_of:

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

Sử dụng boost gán:

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

STL thông thường:

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

STL thông thường với các macro chung:

#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 thông thường với macro khởi tạo vector:

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

Chỉ cần nghĩ rằng tôi đã ném 0,02 đô la của tôi. Tôi có xu hướng tuyên bố điều này:

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

trong một tiêu đề tiện ích ở đâu đó và sau đó tất cả những gì cần thiết là:

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

Nhưng tôi không thể đợi C ++ 0x. Tôi bị kẹt vì mã của tôi cũng phải biên dịch trong Visual Studio. Boo.

Trước C ++ 11:

Phương pháp 1 =>

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

Phương pháp 2 =>

 v.push_back(SomeValue);

C ++ 11 trở đi bên dưới cũng có thể

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

Bắt đầu với:

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

Nếu bạn không có trình biên dịch C ++ 11 và bạn không muốn sử dụng boost:

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

Nếu bạn không có trình biên dịch C ++ 11 và có thể sử dụng boost:

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

Nếu bạn có trình biên dịch C ++ 11:

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

Đối với khởi tạo véc tơ -

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

có thể được thực hiện nếu bạn có trình biên dịch c ++ 11.

Khác, bạn có thể có một mảng dữ liệu và sau đó sử dụng một vòng lặp for.

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

Ngoài những cách này, có nhiều cách khác được mô tả ở trên bằng cách sử dụng một số mã. Theo tôi, những cách này rất dễ nhớ và nhanh chóng để viết.

Cách dễ nhất để làm điều đó là:

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

Tôi xây dựng giải pháp của riêng tôi bằng cách sử dụng va_arg. Giải pháp này tuân thủ 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;
}

Bản giới thiệu

Nếu trình biên dịch của bạn hỗ trợ các macro Variadic (đúng với hầu hết các trình biên dịch hiện đại), thì bạn có thể sử dụng macro sau đây để biến khởi tạo vector thành một lớp lót:

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

Với macro này, bạn có thể xác định một vectơ khởi tạo với mã như thế này:

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

Điều này sẽ tạo ra một vectơ mới của ints có tên my_vector với các phần tử 1, 2, 3, 4.

Nếu bạn không muốn sử dụng boost, nhưng muốn tận hưởng cú pháp như

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

chỉ bao gồm đoạn mã này

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

Trong C ++ 11:

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

bạn có thể làm điều đó bằng cách sử dụng boost :: gán.

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

chi tiết tại đây

Một câu hỏi trùng lặp gần đây hơn có câu trả lời này của Viktor Sehr . Đối với tôi, nó nhỏ gọn, hấp dẫn trực quan (có vẻ như bạn đang 'đẩy' các giá trị vào), không yêu cầu c ++ 11 hoặc mô-đun của bên thứ ba và tránh sử dụng biến phụ (bằng văn bản). Dưới đây là cách tôi đang sử dụng nó với một vài thay đổi. Tôi có thể chuyển sang mở rộng chức năng của vectơ và / hoặc va_arg trong phần mở đầu trong tương lai.

// 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ác phương thức dưới đây có thể được sử dụng để khởi tạo vector trong 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); và như thế

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

Cái thứ ba chỉ được phép trong C ++ 11 trở đi.

Có rất nhiều câu trả lời hay ở đây, nhưng vì tôi đã tự mình đến trước khi đọc nó, tôi nghĩ rằng dù sao tôi cũng sẽ ném nó lên đây ...

Đây là một phương pháp mà tôi đang sử dụng cho phương pháp này sẽ hoạt động phổ biến trên các trình biên dịch và nền tảng:

Tạo một cấu trúc hoặc lớp như một thùng chứa cho bộ sưu tập các đối tượng của bạn. Xác định hàm quá tải toán tử cho <<.

class MyObject;

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

Bạn có thể tạo các hàm lấy cấu trúc của bạn làm tham số, ví dụ:

someFunc( MyObjectList &objects );

Sau đó, bạn có thể gọi hàm đó, như thế này:

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

Bằng cách đó, bạn có thể xây dựng và chuyển một bộ sưu tập các đối tượng có kích thước động đến một hàm trong một dòng sạch duy nhất!

Nếu bạn muốn một cái gì đó theo cùng thứ tự chung như Boost :: gán mà không tạo ra sự phụ thuộc vào Boost, thì sau đây ít nhất là tương tự mơ hồ:

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

Mặc dù tôi muốn cú pháp sử dụng nó sạch hơn, nhưng nó vẫn không đặc biệt khủng khiếp:

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

Để biên dịch sử dụng:

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.

Nếu mảng là:

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 

Nó khá thuận tiện để tạo một vectơ nội tuyến mà không xác định biến khi viết bài kiểm tra, ví dụ:

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

Liên quan, bạn có thể sử dụng các mục sau nếu bạn muốn có một vectơ hoàn toàn sẵn sàng để đi vào một câu lệnh nhanh (ví dụ: ngay lập tức chuyển sang hàm khác):

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

chức năng ví dụ

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

sử dụng ví dụ

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

mặc dù hãy cẩn thận về số thập phân, đảm bảo giá trị đầu tiên rõ ràng là những gì bạn muốn.

Có nhiều cách khác nhau để mã hóa một vectơ, tôi sẽ chia sẻ một vài cách:

1. Khởi tạo bằng cách đẩy từng giá trị một

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

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

2. Khởi tạo như mảng

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

3. Đang khởi tạo từ một mảng

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

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

4. Bắt đầu từ một vector khác

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

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

"Làm cách nào để tạo một vectơ STL và khởi tạo nó như trên? Cách tốt nhất để làm điều đó với nỗ lực gõ tối thiểu là gì?"

Cách dễ nhất để khởi tạo một vectơ khi bạn khởi tạo mảng dựng sẵn của mình là sử dụng danh sách trình khởi tạo được giới thiệu trong 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 có 3 phần tử kích thước sau khi Assigning (câu lệnh được gắn nhãn) được thực thi.

B. Stroustrup mô tả một cách hay để vận hành chuỗi trong 16.2.10 Selfreference trên trang 464 trong phiên bản C ++ 11 của Prog. Lang. trong đó một hàm trả về một tham chiếu, ở đây được sửa đổi thành một vectơ. Bằng cách này bạn có thể xâu chuỗi như thế v.pb(1).pb(2).pb(3);nhưng có thể là quá nhiều công việc cho những lợi ích nhỏ như vậy.

#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ách đơn giản nhất, tiện dụng hơn (với C ++ 11 trở lên):

auto my_ints = {1,2,3};

Trong trường hợp bạn muốn có nó trong lớp của riêng bạn:

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