By Agnel Kurian

2010-02-10 10:55:33 8 Comments

I can create an array and initialize it like this:

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

How do I create a std::vector and initialize it similarly elegant?

The best way I know is:

std::vector<int> ints;


Is there a better way?


@nz_21 2020-04-16 14:28:25

The simplest, ergonomic way (with C++ 11 or later):

auto my_ints = {1,2,3};

@user2103487 2013-02-24 00:04:28

"How do I create an STL vector and initialize it like the above? What is the best way to do so with the minimum typing effort?"

The easiest way to initialize a vector as you've initialized your built-in array is using an initializer list which was introduced in C++11.

// Initializing a vector that holds 2 elements of type int.
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.

ivec is 3 elements in size after Assigning (labeled statement) is executed.

@pdk 2013-09-08 07:42:21

In the similar lines , I am trying to initialise the map, std::map<int, bool> catinfo = { {1, false} }; But then get this error error: in C++98 'catinfo' must be initialized by constructor, not by '{...}'

@mbells 2013-10-07 21:30:03

In C++11:

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

Using boost list_of:

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

Using boost assign:

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

Conventional STL:

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

Conventional STL with generic macros:

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

Conventional STL with a vector initializer macro:

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

@Jaege 2016-12-17 04:57:54

C++11 also support std::begin and std::end for array, so a vector can also be initialized like static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr));.

@Othermusketeer 2014-04-12 22:37:11

A more recent duplicate question has this answer by Viktor Sehr. For me, it is compact, visually appealing (looks like you are 'shoving' the values in), doesn't require c++11 or a third party module, and avoids using an extra (written) variable. Below is how I am using it with a few changes. I may switch to extending the function of vector and/or va_arg in the future intead.

// Based on answer by "Viktor Sehr" on Stack Overflow
template <typename T>
class mkvec {
    typedef mkvec<T> my_type;
    my_type& operator<< (const T& 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_;
    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)

@BuvinJ 2016-10-12 14:30:06

There are a lot of good answers here, but since I independently arrived at my own before reading this, I figured I'd toss mine up here anyway...

Here's a method that I'm using for this which will work universally across compilers and platforms:

Create a struct or class as a container for your collection of objects. Define an operator overload function for <<.

class MyObject;

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

You can create functions which take your struct as a parameter, e.g.:

someFunc( MyObjectList &objects );

Then, you can call that function, like this:

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

That way, you can build and pass a dynamically sized collection of objects to a function in one single clean line!

@Tush_08 2017-06-28 17:34:32

For vector initialisation -

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

can be done if you have C++11 compiler.

Else, you can have an array of the data and then use a for loop.

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

Apart from these, there are various other ways described above using some code. In my opinion, these ways are easy to remember and quick to write.

@NixoN 2020-06-05 16:09:50

In case you want to have it in your own class:

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

@Anil Gupta 2020-05-27 18:02:24

There are various ways to hardcode a vector, i will share few ways:

  1. Initializing by pushing values one by one
// Create an empty vector 
    vector<int> vect;  

  1. Initializing like arrays
vector<int> vect{ 10, 20, 30 };
  1. Initializing from an array
    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 
  1. Initializing from another vector
    vector<int> vect1{ 10, 20, 30 }; 

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

@Daniel Stracaboško 2019-12-03 14:21:24

It is pretty convenient to create a vector inline without defining variable when writing test, for example:

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

@aloisdg moving to 2014-04-05 11:02:37

I build my own solution using va_arg. This solution is C++98 compliant.

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


@Adam Erickson 2018-06-14 00:35:02

If you can, use the modern C++[11,14,17,...] way:

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

The old way of looping over a variable-length array or using sizeof() is truly terrible on the eyes and completely unnecessary in terms of mental overhead. Yuck.

@Adam Erickson 2018-09-16 20:55:04

In fairness, this was originally a C++03 question, but I hope that people/companies adopt the new standards. C++ still needs a variable-length array (VLA) implementation in the standard library similar to what is available in Eigen and Boost.

@Lightness Races in Orbit 2019-02-27 12:31:09

Unfortunately, this approach is problematic in some cases e.g. Yuck.

@Adam Erickson 2019-06-20 23:30:20

If "list-initialization of an aggregate from an object of the same type" is your thing, probably there are bigger problems in your codebase... I can think of no application where it would justify the debugging problems.

@Noone AtAll 2020-08-03 15:01:15

answer from 2018 and still uses ={}?

@backslashN 2020-09-13 13:34:56

Still no need of =

@FaridLU 2017-10-02 12:38:46

If the array is:

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 

@A J 2016-08-03 09:13:31

Before C++ 11 :

Method 1=>

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

Method 2 =>


C++ 11 onward below is also possible

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

@sg7 2016-11-16 23:40:20

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

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

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++) = C[i];                           // initialize vArrayC

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

@Piti Ongmongkolkul 2011-12-23 11:09:21

If you don't want to use boost, but want to enjoy syntax like

std::vector<int> v;

just include this chunk of code

template <class T> class vector_inserter{
    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;

@Daniel Buckmaster 2012-04-03 10:06:04

I haven't been able to figure out how to use this code, but it looks interesting.

@Piti Ongmongkolkul 2012-04-04 01:10:04

It's like one of the comment above said. Just overloading += and comma operator. Putting parenthesis for clarity : ((((v+=1),2),3),4),5) This is how it works: First, vector<T> += T returns a vector_inserter lets call it vi which encapsulate the original vector then vi,T add T to original vector which vi encapsulate and return it self so that we can do vi,T again.

@Yevhen 2012-06-13 12:56:55

this code didn't worked correctly on gcc 4.2.1 i think because of returning reference to a local variable inside += operator but idea is exellent. i edited code and there appears one more copy constructor. flow is now -> += -> ctor -> comma -> copy -> dtor -> comma ...... -> comma -> dtor.

@Speed8ump 2018-02-23 18:22:54

I'd have probably overloaded << instead of +=. At least << already has vague side effect rules because of bit shifts and cout

@Jay 2016-08-02 14:05:30

Below methods can be used to initialize the vector in 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); and so on

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

The third one is allowed only in C++11 onwards.

@kometen 2016-02-17 22:29:41

B. Stroustrup describes a nice way to chain operations in 16.2.10 Selfreference on page 464 in the C++11 edition of the Prog. Lang. where a function returns a reference, here modified to a vector. This way you can chain like v.pb(1).pb(2).pb(3); but may be too much work for such small gains.

#include <iostream>
#include <vector>

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

using namespace std;

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


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

    return 0;


@Agnel Kurian 2016-02-19 04:31:08

The armadillo library does this for matrix initialisation but uses the << operator instead of a named function:

@BufBills 2014-11-28 19:27:37

In C++11:

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

@Bernhard Barker 2015-02-24 13:09:25

If you're using C++11 already, you may as well go for the direct approach - vector<int> arr = {10, 20, 30};.

@Nebula 2015-07-20 07:52:55

Actually I had an incoming int[] (some C lib) and wanted to push into a vector (C++ lib). This answer helped, the rest didn't ;-)

@Carl 2014-12-12 00:01:14

Starting with:

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

If you don't have a C++11 compiler and you don't want to use boost:

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

If you don't have a C++11 compiler and can use boost:

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

If you do have a C++11 compiler:

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

@shaveenk 2014-02-20 18:24:36

typedef std::vector<int> arr;

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

To compile use:

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

@Mike P 2014-09-08 09:55:42

Question states C++ 03 (not 11)

@shaveenk 2014-09-08 17:26:38

I think it didn't specify 03 when I answered this. Don't remember perfectly though. However, it is still a useful answer for someone looking for a quick solution.

@Manuel 2010-02-10 11:01:13

If your compiler supports C++11, you can simply do:

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

This is available in GCC as of version 4.4. Unfortunately, VC++ 2010 seems to be lagging behind in this respect.

Alternatively, the Boost.Assign library uses non-macro magic to allow the following:

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

But keep in mind that this has some overhead (basically, list_of constructs a std::deque under the hood) so for performance-critical code you'd be better off doing as Yacoby says.

@Azurespot 2018-03-08 02:03:55

Since vectors are self-sizing, would it be ok to initialize it as empty too? Like in the constructor: this->vect = {}; ?

@Luke 2018-04-05 23:33:17

@Azurespot You can just initialise it, and it will be empty: std::vector<T> vector;

@simomo 2019-03-01 15:48:36

Just in case somebody may be curious about std::vector<int> v = {1, 2, 3, 4};, vector's initializer list constructor will be called for this sort of initializing, its doc can be find in the C++ 11 section.

@David Rodríguez - dribeas 2010-02-10 11:00:15

In C++0x you will be able to do it in the same way that you did with an array, but not in the current standard.

With only language support you can use:

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

If you can add other libraries you could try boost::assignment:

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

To avoid hardcoding the size of an array:

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

@Manuel 2010-02-10 11:26:59

Of course I didn't downvote but I have a question anyway: when is the size of an array not a compile time constant? I.e., in which cases would you use the first solution in your second snippet as opposed to the third one?

@Sebastian Mach 2010-02-10 11:36:28

+vote from my side. In C++0x you could make a constexpr of option 1. But then again, this won't be used anymore then :S

@David Rodríguez - dribeas 2010-02-10 11:45:48

@Manuel, the size of the array is part of the type, and as such it is a compile time constant. Now, option 1 uses that compile time constant 'N' as return value for a function. The return of a function is not a compile time, but runtime value, even if it will probably get inlined as the constant value at the place of call. The difference is that you cannot do: int another[size_of_array(array)], while you can do int another[ARRAY_SIZE(array)].

@sellibitze 2010-02-10 12:48:52

@Manuel: incomplete array types also exist, like int[]. I can put a declaration of such an array in a header and define it somewhere else (with completed type). Then, the size is not known during compilation of all other traslation units that just include the header. Array-to-pointer decay still works, sizeof does not.

@To1ne 2011-06-06 06:40:23

In option 3: I don't really get what you mean with "declared, undefined "? So the variable will not take additional memory?

@David Rodríguez - dribeas 2012-01-20 12:51:06

@To1ne that is actually a function declaration, not a variable. The reason for or defining it is that we don't actually want the function for anything else other than the sizeof expression that does not need a definition. While you can actually provide a definition, to do it right would require the static allocation of an array and returning a reference to it, and the next question would be what would make sense as values for the array? (Also note that this means one array per type/size combination of the function's instantiations!) Since the is no sensible use for it, I'd rather avoid it.

@mhd 2016-10-11 13:33:34

The option 1 doesn't work in the case of empty array: int arr[0] = {}; std::size_t num = size_of_array(arr); Compiler will print something like: no matching function for call to 'size_of_array(int [0])' std::size_t num = size_of_array(arr);

@David Rodríguez - dribeas 2016-10-13 11:03:55

@mhd: You cannot construct an empty array in the language. 'int arr[0] = {};' is not valid C++ code. But you are right that if you want to initialize an empty vector and a non-empty vector you will have to use different constructs. Since C++11 this is a non-issue as you can use the initializer list constructor

@Don Hatch 2019-04-17 18:37:18

Your ARRAY_SIZE macro #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) is more unsafe than necessary. Please parenthesize it properly: #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) or #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))

@Josh 2013-05-07 00:54:45

Related, you can use the following if you want to have a vector completely ready to go in a quick statement (e.g. immediately passing to another function):

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

example function

template<typename T>
void test(std::vector<T>& values)
    for(T value : values)

example use


though be careful about the decltype, make sure the first value is clearly what you want.

@Paul Baltescu 2013-01-24 18:29:23

The easiest way to do it is:

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

@Agnel Kurian 2013-01-26 06:23:15

Which compiler? Are you using C++11 here?

@Paul Baltescu 2013-01-28 15:56:34

g++ 4.6.3 with -std=c++0x.

@M. Tibbits 2011-04-03 04:15:41

Just thought I'd toss in my $0.02. I tend to declare this:

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

in a utility header somewhere and then all that's required is:

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

But I can't wait for C++0x. I'm stuck because my code must also compile in Visual Studio. Boo.

@Andres Riofrio 2012-10-08 22:03:34

This technique can also be used to overload a function to accept an array with typed size.

@Patryk 2015-03-12 15:04:37

Can you explain the const T (&data)[N] part? How is the size of the array deduced in your call makeVector(values)?

@Matt Ball 2010-09-25 18:21:08

If your compiler supports Variadic macros (which is true for most modern compilers), then you can use the following macro to turn vector initialization into a one-liner:

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

With this macro, you can define an initialized vector with code like this:

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

This would create a new vector of ints named my_vector with the elements 1, 2, 3, 4.

@Jerry Coffin 2010-02-10 19:35:46

If you want something on the same general order as Boost::assign without creating a dependency on Boost, the following is at least vaguely similar:

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

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

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

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

While I wish the syntax for using it was cleaner, it's still not particularly awful:

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

@Yacoby 2010-02-10 11:00:28

One method would be to use the array to initialize the vector

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

@Yacoby 2010-02-10 16:55:59

@Agnel It will work fine without static or const, however they both make it more explicit as to how it should be used and allow the compiler to make additional optimizations.

@T.E.D. 2011-05-03 18:50:28

I didn't downvoate this, but I was tempted. Mainly because this saves you almost nothing over just using the initialized array in the first place. However, that's really C++'s fault, not yours.

@DomX23 2012-01-27 05:23:09

Can you explain why you're using those parameters when defining the vec vector.

@Johnny Pauling 2012-08-17 12:58:20

sizeof(array) is one of the few exceptions that allows to get the total size of elements of the array and NOT the arr pointer dimension. So basically he's using vector(pointer_to_first_element, pointer_to_first_element + size_in_bytes_of_the_whole_array / size_of_one_element) that is: vector(pointer_to_first_element, pointer_after_final_element). The type is already given with the <int>, so the vector knows how much is one element. Remember that iterators can be treated as pointers so you're basically using the vector(iterator begin, iterator end) constructor

@Luis Machuca 2012-10-21 03:25:26

Not only is this method easy and standalone without any extra requirements, but it can also be made forwards-compatible with C++0x and their container initialization lists with the help of a macro, which eases syntax and portability a lot. +1.

@qwerty9967 2013-03-27 13:49:40

It seems that if I use static const string attr[]={"abc", "def","ghi"} that I can't use sizeof to get the array length. It also doesn't seem to work for arrays of char *'s. Am I doing something wrong?

@qwerty9967 2013-03-27 14:03:45

Actually ... the sizeof trick works just fine until I pass the array into a function. Then it seems to not work any more. Is there a way around that?

@Victor K 2013-04-26 08:10:49

@qwerty9967 When you pass an array into a function by pointer, you should always pass the size of the array as well, unless the function infers the size of the array from the array contents (e.g. if the last element contains terminating value etc.). That's why C++ has std::vector, so passing it by reference will solve your problem.

@DarkWanderer 2014-02-18 09:24:56

@T.E.D: Sometimes you need to modify the resulting vector. For example, you may need to always have some default parameters and sometimes add a few customized to them.

@MasterHD 2016-07-14 05:52:29

Doesn't this imply that two duplicate copies of the integers are now being stored in memory? Is there at least a way to destroy the static const int arr[] afterward to free up that memory? Even without the static keyword, a global variable would remain allocated for the entirety of the program. This could become an issue when dealing with many/large vectors of doubles, strings, etc.

@einpoklum 2017-03-11 21:12:25

A solution involving an auxiliary variable, sizeof() and multiple arithmetic operations including a division is anything but "the easiest way". -1.

@f4. 2010-02-10 11:02:12

you can do that using boost::assign.

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

detail here

@bobobobo 2013-11-09 20:42:45

I haven't seen a worse case of operator overloading abuse in a long time. Does the += there tack on 1,2,3,4.. to the end of values, or does it add 1 to the 1st element, 2 to the 2nd element, 3 to the 3rd element (as syntax like this should in MATLAB-like languages)

Related Questions

Sponsored Content

14 Answered Questions

[SOLVED] How to directly initialize a HashMap (in a literal way)?

15 Answered Questions

[SOLVED] How do I erase an element from std::vector<> by index?

  • 2009-05-17 17:59:36
  • dau_man
  • 804601 View
  • 536 Score
  • 15 Answer
  • Tags:   c++ stl vector erase

18 Answered Questions

[SOLVED] How to find out if an item is present in a std::vector?

  • 2009-02-20 21:58:41
  • Joan Venge
  • 957961 View
  • 633 Score
  • 18 Answer
  • Tags:   c++ vector std

28 Answered Questions

[SOLVED] Easiest way to convert int to string in C++

25 Answered Questions

[SOLVED] Concatenating two std::vectors

79 Answered Questions

[SOLVED] How do I iterate over the words of a string?

  • 2008-10-25 08:58:21
  • Ashwin Nanjappa
  • 2197671 View
  • 3032 Score
  • 79 Answer
  • Tags:   c++ string split

17 Answered Questions

[SOLVED] Iteration over std::vector: unsigned vs signed index variable

18 Answered Questions

[SOLVED] Why should C++ programmers minimize use of 'new'?

6 Answered Questions

[SOLVED] How to initialize std::vector from C-style array?

Sponsored Content