I need to store multiple types of a template class in a single vector.

Eg, for:

    template &lt;typename T&gt;
    class templateClass{
         bool someFunction();
    };

I need one vector that will store all of:

    templateClass&lt;int&gt; t1;
    templateClass&lt;char&gt; t2;
    templateClass&lt;std::string&gt; t3;
    etc

As far as I know this is not possible, if it is could someone say how?


If it isn&#39;t  possible could someone explain how to make the following work?

As a work around I tried to use a base, non template class and inherit the template class from it.

     class templateInterface{
         virtual bool someFunction() = 0;
     };

     template &lt;typename T&gt;
     class templateClass : public templateInterface{
         bool someFunction();
     };
I then created a vector to store the base &quot;templateInterface&quot; class:
    
    std::vector&lt;templateInterface&gt; v;
    templateClass&lt;int&gt; t;
    v.push_back(t);

This produced the following error:

    error: cannot allocate an object of abstract type &#39;templateInterface&#39;
    note: because the following virtual functions are pure within &#39;templateInterface&#39;
    note: virtual bool templateInterface::someFunction()

To fix this error I made the function in templateInterface not a pure virtual by providing a function body, this compiled but when calling the function the overide is not used, but instead the body in the virtual function.

Eg:

     class templateInterface{
         virtual bool someFunction() {return true;}
     };

     template &lt;typename T&gt;
     class templateClass : public templateInterface{
         bool someFunction() {return false;}
     };

     std::vector&lt;templateInterface&gt; v;
     templateClass&lt;int&gt; i;
     v.push_back(i);
     v[0].someFunction(); //This returns true, and does not use the code in the &#39;templateClass&#39; function body

Is there any way to fix this so that the overridden function is used, or is there another workaround to store multiple template types in a single vector?


     



C++ One std::vector containing template class of multiple types

What&#39;s the fastest way to reset every value of a `std::vector&lt;int&gt;` to 0 and keeping the vectors initial size ? 

A for loop with the [] operator ? 

Fastest way to reset every value of std::vector&lt;int&gt; to 0

After a lot of investigations with valgrind, I&#39;ve made the conclusion that std::vector makes a copy of an object you want to push_back.

Is that really true ? A vector cannot keep a reference or a pointer of an object without a copy ?!

Thanks

Is std::vector copying the objects with a push_back?

How do I concatenate two `std::vector`s?


Concatenating two std::vectors

I like vectors a lot. They&#39;re nifty and fast. But I know this thing called a valarray exists. Why would I use a valarray instead of a vector? I know valarrays have some syntactic sugar, but other than that, when are they useful?

C++ valarray vs. vector

I need to copy `std::set` to `std::vector`:

    std::set &lt;double&gt; input;
    input.insert(5);
    input.insert(6);
	
    std::vector &lt;double&gt; output;
    std::copy(input.begin(), input.end(), output.begin()); //Error: Vector iterator not dereferencable

Where is the problem?

C++, copy set to vector

How much data is copied, when returning a `std::vector` in a function and how big an optimization will it be to place the std::vector in free-store (on the heap) and return a pointer instead i.e. is:

    std::vector *f()
    {
      std::vector *result = new std::vector();
      /*
        Insert elements into result
      */
      return result;
    } 

more efficient than:

    std::vector f()
    {
      std::vector result;
      /*
        Insert elements into result
      */
      return result;
    } 

?

Efficient way to return a std::vector in c++

If I have a vector of pairs:

    std::vector&lt;std::pair&lt;int, int&gt; &gt; vec;

Is there and easy way to sort the list in **increasing** order based on the second element of the pair?

I know I can write a little function object that will do the work, but is there a way to use existing parts of the *STL* and `std::less` to do the work directly?

EDIT:  I understand that I can write a separate function or class to pass to the third argument to sort.  The question is whether or not I can build it out of standard stuff.  I&#39;d really something that looks like:

    std::sort(vec.begin(), vec.end(), std::something_magic&lt;int, int, std::less&gt;());



How do I sort a vector of pairs based on the second element of the pair?

I know that `at()` is slower than `[]` because of its boundary checking, which is also discussed in similar questions like https://stackoverflow.com/q/2578638/1168156  or https://stackoverflow.com/q/3269809/1168156. I just don&#39;t understand what the `at()` method is good for.

If I have a simple vector like this one: `std::vector&lt;int&gt; v(10);` and I decide to access its elements by using `at()` instead of `[]` in situation when I have a index `i` and I&#39;m not sure if its in vectors bounds, it forces me to **wrap it with try-catch block**:

    try
    {
        v.at(i) = 2;
    }
    catch (std::out_of_range&amp; oor)
    {
        ...
    }

although I&#39;m able to do the get the same behaviour by using `size()` and checking the index on my own, which seems easier and much convenient for me:

    if (i &lt; v.size())
        v[i] = 2;

So my question is:  
**What are advantages of using [vector::at](http://www.cplusplus.com/reference/stl/vector/at/) over [vector::operator[]](http://www.cplusplus.com/reference/stl/vector/operator%5B%5D/) ?**  
**When should I use [vector::at](http://www.cplusplus.com/reference/stl/vector/at/) rather than [vector::size](http://www.cplusplus.com/reference/stl/vector/size/) + [vector::operator[]](http://www.cplusplus.com/reference/stl/vector/operator%5B%5D/) ?**



vector::at vs. vector::operator[]

I am looking for a generic, reusable way to shuffle a `std::vector` in C++. This is how I currently do it, but I think it&#39;s not very efficient because it needs an intermediate array and it needs to know the item type (DeckCard in this example):

	srand(time(NULL));
	
	cards_.clear();
	
	while (temp.size() &gt; 0) {
		int idx = rand() % temp.size();
		DeckCard* card = temp[idx];
		cards_.push_back(card);
		temp.erase(temp.begin() + idx);
	}

How to shuffle a std::vector?

Is there any built in function which tells me that my vector contains a certain element or not
e.g.

    std::vector&lt;string&gt; v;
    v.push_back(&quot;abc&quot;);
    v.push_back(&quot;xyz&quot;);
    
    if (v.contains(&quot;abc&quot;)) // I am looking for one such feature, is there any
                           // such function or i need to loop through whole vector?


In C++ check if std::vector&lt;string&gt; contains a certain value

I&#39;m using a external library which at some point gives me a raw pointer to an array of integers and a size.

Now I&#39;d like to use `std::vector` to access and modify these values in place, rather than accessing them with raw pointers.

Here is an articifial example that explains the point:

    size_t size = 0;
	int * data = get_data_from_library(size);   // raw data from library {5,3,2,1,4}, size gets filled in
	
	std::vector&lt;int&gt; v = ????;                  // pseudo vector to be used to access the raw data
	
	std::sort(v.begin(), v.end());              // sort raw data in place

	for (int i = 0; i &lt; 5; i++)
	{
	  std::cout &lt;&lt; data[i] &lt;&lt; &quot;\n&quot;;             // display sorted raw data 
	}

Expected output:

	1
	2
	3
	4
	5


The reason is that I need to apply algorithms from `&lt;algorithm&gt;` (sorting, swaping elements etc.) on that data.

On the other hand changing the size of that vector would never be changed, so `push_back`, `erase`, `insert` are not required to work on that vector.

I could construct a vector based on the data from the library, use modify that vector and copying the data back to to library, but that would be two complete copies that I&#39;d like to avoid as the data set could be really big.

Using std::vector as view on to raw memory

C++14 presents [`std::dynarray`][1]:

&gt; std::dynarray is a sequence container that encapsulates arrays with a
&gt; size that is fixed at construction and does not change throughout the
&gt; lifetime of the object.

`std::dynarray` must be allocated in run-time as same as `std::vector`.

So what are the benefits and the usage of `std::dynarray` while we can use `std::vector` which is more dynamic (and also re-sizable)?




  [1]: http://en.cppreference.com/w/cpp/container/dynarray

std::dynarray vs std::vector

I have the following Java code with several big arrays which never change their size. It runs in 1100 ms on my computer.

I implemented the same code in C++ and used `std::vector`.

The time of the C++ implementation which runs the exact same code is 8800 ms on my computer. What did I do wrong, so that it runs this slowly?

Basically the code does the following:

    for (int i = 0; i &lt; numberOfCells; ++i) {
            h[i] =  h[i] + 1;
            floodedCells[i] =  !floodedCells[i];
            floodedCellsTimeInterval[i] =  !floodedCellsTimeInterval[i];
            qInflow[i] =  qInflow[i] + 1;
    }

It iterates through different arrays with a size of around 20000.

You can find both implementations under the following links:

- Java: https://ideone.com/R8KqjT
- C++: https://ideone.com/Lu7RpE

(On ideone I could only run the loop 400 times instead of 2000 times because of the time limitation. But even here there is a difference of three times)

Java 8 times faster with arrays than std::vector in C++. What did I do wrong?

Is there any way to compare two vectors?

    if (vector1 == vector2)
        DoSomething();

**Note:** Currently, these vectors are not sorted and contain integer values.



How to compare two vectors for equality element by element in C++?

Could someone tell what is the correct way to work with a vector of arrays? 

I declared a vector of arrays (`vector&lt;float[4]&gt;`) but got `error: conversion from &#39;int&#39; to non-scalar type &#39;float [4]&#39; requested` when trying to `resize` it. What is going wrong?



Correct way to work with vector of arrays

I have long assumed that for any empty `std::vector` *V*, `V.begin() == V.end()`. Yet I see nothing in the C++ specification that states this to *always* be true. Is it necessarily true or does it just happen to be true on most implementations?

Is begin() == end() for any empty() vector?

I am developing a C++ application using CodeBlocks 10.05 on Debian 7.0.0.

For some reason, the following code


    #include &lt;iostream&gt;

    std::vector&lt; int &gt; delaunayDiv(const std::vector&lt; int &lt;T&gt; &gt; &amp; vP, cv::Rect boundRect,
        std::vector&lt;int&gt;&amp; triangles, int&amp; numTriangles, bool lookRight);

returns the following error

    error: &#39;vector&#39; in namespace &#39;std&#39; does not name a type


&#39;vector&#39; in namespace &#39;std&#39; does not name a type

How do I print out the contents of a `std::vector` to the screen?


----------


A solution that implements the following `operator&lt;&lt;` would be nice as well:
```
template&lt;container C, class T, String delim = &quot;, &quot;, String open = &quot;[&quot;, String close = &quot;]&quot;&gt;
std::ostream &amp; operator&lt;&lt;(std::ostream &amp; o, const C&lt;T&gt; &amp; x)
{
  // ... What can I write here?
}
```

----------

Here is what I have so far, without a separate function:

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    #include &lt;string&gt;
    #include &lt;cmath&gt;
    #include &lt;vector&gt;
    #include &lt;sstream&gt;
    #include &lt;cstdio&gt;
    using namespace std;
    
    int main()
    {
    	ifstream file(&quot;maze.txt&quot;);
    	if (file) {
    		vector&lt;char&gt; vec(istreambuf_iterator&lt;char&gt;(file), (istreambuf_iterator&lt;char&gt;()));
    		vector&lt;char&gt; path;
    		int x = 17;
    		char entrance = vec.at(16);
    		char firstsquare = vec.at(x);
    		if (entrance == &#39;S&#39;) { 
    			path.push_back(entrance); 
    		}
    		for (x = 17; isalpha(firstsquare); x++) {
    			path.push_back(firstsquare);
    		}
    		for (int i = 0; i &lt; path.size(); i++) {
    			cout &lt;&lt; path[i] &lt;&lt; &quot; &quot;;
    		}
    		cout &lt;&lt; endl;
    		return 0;
    	}
    }


How do I print out the contents of a vector?

Consider the following program which inserts a range of elements into a vector:

    vector&lt;string&gt; v1;
    vector&lt;string&gt; v2;
    
    v1.push_back(&quot;one&quot;);
    v1.push_back(&quot;two&quot;);
    v1.push_back(&quot;three&quot;);

    v2.push_back(&quot;four&quot;);
    v2.push_back(&quot;five&quot;);
    v2.push_back(&quot;six&quot;);
    
    v1.insert(v1.end(), v2.begin(), v2.end());

This efficiently copies the range, allocating enough space in the target vector for the entire range so that a maximum of one resize will be required.  Now consider the following program which attempts to move a range into a vector:

    vector&lt;string&gt; v1;
    vector&lt;string&gt; v2;
    
    v1.push_back(&quot;one&quot;);
    v1.push_back(&quot;two&quot;);
    v1.push_back(&quot;three&quot;);
    
    v2.push_back(&quot;four&quot;);
    v2.push_back(&quot;five&quot;);
    v2.push_back(&quot;six&quot;);
    
    for_each ( v2.begin(), v2.end(), [&amp;v1]( string &amp; s )
    {
    	v1.emplace_back(std::move(s));
    });

This performs a successful move but doesn&#39;t enjoy the benefits that insert() has with regard to preallocating space in the target vector, so the vector could be resized several times during the operation.  

So my question is, is there an insert equivalent which can move a range into a vector?

Is there a standard way of moving a range into a vector?

I would like to be able to convert between std::vector&lt;int&gt; and its underlying C array int* without explicitly copying the data. 

Does std::vector provide access to the underlying C array? I am looking for something like this 

    vector&lt;int&gt; v (4,100)
    int* pv = v.c_array();

EDIT:

Also, is it possible to do the converse, i.e. how would I initialize an `std::vector` from a C array without copying?

    int pv[4] = { 4, 4, 4, 4};
    vector&lt;int&gt; v (pv);


Converting between C++ std::vector and C array without copying

I have two STL vectors `A` and `B` and I&#39;d like to clear all elements of `A` and move all elements of `B` to `A` and then clear out `B`. Simply put, I want to do this:

    std::vector&lt;MyClass&gt; A;
    std::vector&lt;MyClass&gt; B;
    ....
    A = B;
    B.clear();

Since `B` could be pretty long, it takes `k*O(N)` to do this operation, where `k` is a constant, and `N` is `max(size_of(A), size_of(B))`. I was wondering if there could be a more efficient way to do so. One thing that I could think of is to define `A` and `B` as pointers and then copy pointers in constant time and clear out `B`.



STL vector: Moving all elements of a vector

I have an application that is performing some processing on some images.

Given that I know the width/height/format etc. (I do), and thinking just about defining a buffer to store the pixel data:

Then, rather than using `new` and `delete []` on an `unsigned char*` and keeping a separate note of the buffer size, I&#39;m thinking of simplifying things by using a `std::vector`.

So I would declare my class something like this:


    #include &lt;vector&gt;

    class MyClass
    {
        // ... etc. ...

    public:
        virtual void OnImageReceived(unsigned char *pPixels, 
            unsigned int uPixelCount);

    private:
        std::vector&lt;unsigned char&gt; m_pImageBuffer;    // buffer for 8-bit pixels

        // ... etc. ...
    };

Then, when I received a new image (of some variable size - but don&#39;t worry about those details here), I can just resize the vector (if necessary) and copy the pixels:

    void MyClass::OnImageReceived(unsigned char *pPixels, unsigned int uPixelCount)
    {
        // called when a new image is available
        if (m_pImageBuffer.size() != uPixelCount)
        {
            // resize image buffer
            m_pImageBuffer.reserve(uPixelCount);
            m_pImageBuffer.resize(uPixelCount, 0);
        }

        // copy frame to local buffer
        memcpy_s(&amp;m_pImageBuffer[0], m_pImageBuffer.size(), pPixels, uPixelCount);

        // ... process image etc. ...
    }

This seems fine to me, and I like that fact that I don&#39;t have to worry about the memory management, but it raises some questions:

1. Is this a valid application of `std::vector` or is there a more suitable container?
2. Am I doing the right thing performance-wise by calling `reserve` *and* `resize`?
3. Will it *always* be the case that the underlying memory is consecutive so I can use `memcpy_s` as shown?

Any additional comment, criticism or advice would be very welcome.


All Stdvector Solutions on Gang of Coders

Total of 23 Stdvector Solutions