Emplace takes the arguments necessary to construct an object in place, whereas insert takes (a reference to) an object.

    struct Foo
    {
      Foo(int n, double x);
    };
    
    std::vector&lt;Foo&gt; v;
    v.emplace(someIterator, 42, 3.1416);
    v.insert(someIterator, Foo(42, 3.1416));

`insert` copies objects into the vector.

`emplace` *construct* them inside of the vector.


How can you `continue` the parent loop of say two nested loops in Python?

    for a in b:
        for c in d:
            for e in f:
                if somecondition:
                    &lt;continue the for a in b loop?&gt;

I know you can avoid this in the majority of cases but can it be done in Python?

How to continue in nested loops in Python

The extension method `ToList()` returns a `List&lt;TSource&gt;`. Following the same pattern, `ToDictionary()` returns a `Dictionary&lt;TKey, TSource&gt;`.

I am curious why those methods do not type their return values as `IList&lt;TSource&gt;` and `IDictionary&lt;TKey, TSource&gt;` respectively. This seems even odder because `ToLookup&lt;TSource, TKey&gt;` types its return value as an interface instead of an actual implementation.

Looking at the source of those extension methods using [dotPeek][1] or other decompiler, we see the following implementation (showing `ToList()` because it is shorter):
    
    public static List&lt;TSource&gt; ToList&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source) { 
       if (source == null) throw Error.ArgumentNull(&quot;source&quot;);
       return new List&lt;TSource&gt;(source); 
    }

So why does this method type its return value as a specific implementation of the interface and not the interface itself? The only change would be the return type.

I am curious because the `IEnumerable&lt;&gt;` extensions are very consistent in their signatures, except for those two cases. I always thought it to be a bit strange.

Additionally, to make things even more confusing, the [documentation for `ToLookup()`][2] states:

&gt; Creates a Lookup&lt;TKey, TElement&gt; from an IEnumerable&lt;T&gt; according to a
&gt; specified key selector function.

but the return type is `ILookup&lt;TKey, TElement&gt;`.

In [Edulinq][3], Jon Skeet mentions that the return type is `List&lt;T&gt;` instead of `IList&lt;T&gt;`, but does not touch the subject further.  
Extensive searching has yielded no answer, so here I ask you:

**Is there any design decision behind not typing the return values as interfaces, or is it just happenstance?**

  [1]: http://www.jetbrains.com/decompiler/
  [2]: http://msdn.microsoft.com/en-us/library/bb549073.aspx
  [3]: http://code.google.com/p/edulinq/

Why does IEnumerable&lt;T&gt;.ToList&lt;T&gt;() return List&lt;T&gt; instead of IList&lt;T&gt;?

I was wondering what are the differences between the two. I notice that emplace is c++11 addition. So why the addition ?

C++ std::vector emplace vs insert

<p>I was wondering what are the differences between the two. I notice that emplace is c++11 addition. So why the addition ?</p>


I&#39;m not sure how to create a *pure* C++ project with Xcode 4.6:  
  
 ![image of trying to create a new project][1]  

  [1]: https://i.stack.imgur.com/Ktgn0.png

How do I create a new C++ project in Xcode?

I am new to opencv and trying to implement image matching between two images. For this purpose, I&#39;m trying to understand the difference between feature descriptors, descriptor extractors and descriptor matchers. I came across a lot of terms and tried to read about them on the opencv documentation website but I just can&#39;t seem to wrap my head around the concepts. I understood the basic difference here. https://stackoverflow.com/questions/6832933/difference-between-feature-detection-and-descriptor-extraction?rq=1

But I came across the following terms while studying on the topic : 
&gt;FAST, GFTT, SIFT, SURF, MSER, STAR, ORB, BRISK, FREAK, BRIEF 

I understand how FAST, SIFT, SURF work but can&#39;t seem to figure out which ones of the above are only detectors and which are extractors.

Then there are the matchers. 
&gt;FlannBased, BruteForce, knnMatch and probably some others.

After some reading, I figured that certain matchers can only be used with certain extractors as explained here. https://stackoverflow.com/questions/7232651/how-does-opencv-orb-feature-detector-work
The classification given is quite clear but it&#39;s only for a few extractors and I don&#39;t understand the difference between float and uchar. 

So basically, can someone please 

1. classify the types of detectors, extractors and matchers based on float and uchar, as mentioned, or some other type of classification?
2. explain the difference between the float and uchar classification or whichever classification is being used?
3. mention how to initialize (code) various types of detectors, extractors and matchers?

I know its asking for a lot but I&#39;ll be highly grateful.
Thank you.

Classification of detectors, extractors and matchers

How do I decide whether I need `addressof(x)` instead of `&amp;x` when taking the address of an object?

&lt;hr&gt;

Seems like the question was confusing, so a clarification is in order:  

`addressof` obviously bypasses the overloaded address-of operator. **I&#39;m already aware of that.**  

What I want to know is:  
**How do I know if that&#39;s what I really want to do? (Especially when inside a template, etc.)**  

Is there some kind of &quot;rule&quot; that helps me figure out when I need `addressof` instead of `&amp;`?  
After all, they both return the &quot;address of&quot; the object, so when do I use which?

When to use addressof(x) instead of &amp;x?

In this case

    struct Foo {};
    Foo meh() {
      return std::move(Foo());
    }

I&#39;m pretty sure that the move is unnecessary, because the newly created `Foo` will be an xvalue.

But what in cases like these?

    struct Foo {};
    Foo meh() {
      Foo foo;
      //do something, but knowing that foo can safely be disposed of
      //but does the compiler necessarily know it?
      //we may have references/pointers to foo. how could the compiler know?
      return std::move(foo); //so here the move is needed, right?
    }

There the move is needed, I suppose?

When should std::move be used on a function return value?

I have a reference to some class `MyObject`, but the exact object depends on a condition. I want to do something like this:

    MyObject&amp; ref; 
    if([condition]) 
      ref = MyObject([something]);
    else 
      ref = MyObject([something else]);

I cannot do this right now because the compiler does not allow me to declare but not initialize a reference. What can I do to achieve my goal here?

Declare a reference and initialize later?

How can I move some elements from first vector to second, and the elements will remove from the first?  
if I am using `std::move`, the elements not removed from first vector.  
this is the code I wrote:  
  
       move(xSpaces1.begin() + 7, xSpaces1.end(), back_inserter(xSpaces2));

Moving elements from std::vector to another one

I am trying to do a foreach on a vector of attacks, each attack has a **unique ID** say, 1-3.

The class method takes the keyboard input of 1-3.

I am trying to use a foreach to run through my elements in m_attack to see if the number matches, if it does... do something.

The problem I&#39;m seeing is this: 

    a&#39;for each&#39; statement cannot operate on an expression of type &quot;std::vector&lt;Attack

Am I going about this totally wrong, I have C# experience and is kind of what I&#39;m basing this on, any help would be appreciated. 

My code is as follows: 

In header

    vector&lt;Attack&gt; m_attack;
In class


    int Player::useAttack (int input)
    {

	    for each (Attack* attack in m_attack) // Problem part
	    {  
            //Psuedo for following action
	     	if (attack-&gt;m_num == input)
	     	{
                //For the found attack, do it&#39;s damage
	    		attack-&gt;makeDamage();
	     	}
	    }
    }

C++ for each, pulling from vector elements

What are the differences between an array and a vector in C++? An example of the differences might be included libraries, symbolism, abilities, etc.

### Array

&gt; Arrays contain a specific number of elements of a particular type. So that the compiler can reserve the required amount of space when the program is compiled, you must specify the type and number of elements that the array will contain when it is defined. The compiler must be able to determine this value when the program is compiled. Once an array has been defined, you use the identifier for the array along with an index to access specific elements of the array. [...] arrays are zero-indexed; that is, the first element is at index 0. This indexing scheme is indicative of the close relationship in C++ between pointers and arrays and the rules that the language defines for pointer arithmetic.
&gt;
&gt; — C++ Pocket Reference

### Vector

&gt; A vector is a dynamically-sized sequence of objects that provides array-style `operator[]` random access. The member function `push_back` copies its arguments via copy constructor, adds that copy as the last item in the vector and increments its size by one. `pop_back` does the exact opposite, by removing the last element. Inserting or deleting items from the end of a vector takes amortized constant time, and inserting or deleting from any other location takes linear time. These are the basics of vectors. There is a lot more to them. In most cases, a vector should be your first choice over a C-style array. First of all, they are dynamically sized, which means they can grow as needed. You don&#39;t have to do all sorts of research to figure out an optimal static size, as in the case of C arrays; a vector grows as needed, and it can be resized larger or smaller manually if you need to. Second, vectors offer bounds checking with the `at` member function (but not with `operator[]`), so that you can do something if you reference a nonexistent index instead of simply watching your program crash or worse, continuing execution with corrupt data.
&gt;
&gt; — C++ Cookbook


Arrays vs Vectors: Introductory Similarities and Differences

Lately I&#39;ve been asked to write a function that reads the binary file into the `std::vector&lt;BYTE&gt;` where `BYTE` is an `unsigned char`. Quite quickly I came with something like this:

    #include &lt;fstream&gt;
    #include &lt;vector&gt;
    typedef unsigned char BYTE;

    std::vector&lt;BYTE&gt; readFile(const char* filename)
    {
        // open the file:
        std::streampos fileSize;
        std::ifstream file(filename, std::ios::binary);

        // get its size:
        file.seekg(0, std::ios::end);
        fileSize = file.tellg();
        file.seekg(0, std::ios::beg);

        // read the data:
        std::vector&lt;BYTE&gt; fileData(fileSize);
        file.read((char*) &amp;fileData[0], fileSize);
        return fileData;
    }

which seems to be unnecessarily complicated and the explicit cast to `char*` that I was forced to use while calling `file.read` doesn&#39;t make me feel any better about it.  

---
Another option is to use [`std::istreambuf_iterator`](http://www.cplusplus.com/reference/iterator/istreambuf_iterator/):

    std::vector&lt;BYTE&gt; readFile(const char* filename)
    {
        // open the file:
        std::ifstream file(filename, std::ios::binary);

        // read the data:
        return std::vector&lt;BYTE&gt;((std::istreambuf_iterator&lt;char&gt;(file)),
                                  std::istreambuf_iterator&lt;char&gt;());
    }

which is pretty simple and short, but still I have to use the `std::istreambuf_iterator&lt;char&gt;` even when I&#39;m reading into `std::vector&lt;unsigned char&gt;`.

---
The last option that seems to be perfectly straightforward is to use [`std::basic_ifstream&lt;BYTE&gt;`](http://en.cppreference.com/w/cpp/io/basic_ifstream), which kinda expresses it explicitly that *&quot;I want an input file stream and I want to use it to read `BYTE`s&quot;*:

    std::vector&lt;BYTE&gt; readFile(const char* filename)
    {
        // open the file:
        std::basic_ifstream&lt;BYTE&gt; file(filename, std::ios::binary);

        // read the data:
        return std::vector&lt;BYTE&gt;((std::istreambuf_iterator&lt;BYTE&gt;(file)),
                                  std::istreambuf_iterator&lt;BYTE&gt;());
    }

but I&#39;m not sure whether [`basic_ifstream`](http://en.cppreference.com/w/cpp/io/basic_ifstream) is an appropriate choice in this case.

*What is the best way of reading a binary file into the `vector`?* I&#39;d also like to know what&#39;s happening *&quot;behind the scene&quot;* and what are the possible problems I might encounter (apart from stream not being opened properly which might be avoided by simple [`is_open`](http://www.cplusplus.com/reference/fstream/ifstream/is_open/) check).

Is there any good reason why one would prefer to use [`std::istreambuf_iterator`](http://www.cplusplus.com/reference/iterator/istreambuf_iterator/) here?  
(the only advantage that I can see is simplicity)

How to read a binary file into a vector of unsigned chars

I have a (fairly long) list of vectors. The vectors consist of Russian words that I got by using the `strsplit()` function on sentences.

The following is what `head()` returns: 


    [[1]]
    [1] &quot;модно&quot;     &quot;создавать&quot; &quot;резюме&quot;    &quot;в&quot;         &quot;виде&quot;     

    [[2]]
    [1] &quot;ты&quot;        &quot;начианешь&quot; &quot;работать&quot;  &quot;с&quot;         &quot;этими&quot;    

    [[3]]
    [1] &quot;модно&quot;            &quot;называть&quot;         &quot;блогер-рилейшенз&quot; &quot;―&quot;                &quot;начинается&quot;       &quot;задолго&quot;         

    [[4]]
    [1] &quot;видел&quot; &quot;по&quot;    &quot;сыну,&quot; &quot;что&quot;   &quot;он&quot;   

    [[5]]
    [1] &quot;четырнадцать,&quot; &quot;я&quot;             &quot;поселился&quot;     &quot;на&quot;            &quot;улице&quot;        

    [[6]]
    [1] &quot;широко&quot;     &quot;продолжали&quot; &quot;род.&quot;


Note the vectors are of different length.

What I want is to be able to read the first words from each sentence, the second word, the third, etc. 

The desired result would be something like this: 

        P1              P2           P3                 P4    P5           P6
    [1] &quot;модно&quot;         &quot;создавать&quot;  &quot;резюме&quot;           &quot;в&quot;   &quot;виде&quot;       NA
    [2] &quot;ты&quot;            &quot;начианешь&quot;  &quot;работать&quot;         &quot;с&quot;   &quot;этими&quot;      NA
    [3] &quot;модно&quot;         &quot;называть&quot;   &quot;блогер-рилейшенз&quot; &quot;―&quot;   &quot;начинается&quot; &quot;задолго&quot;         
    [4] &quot;видел&quot;         &quot;по&quot;         &quot;сыну,&quot;            &quot;что&quot; &quot;он&quot;         NA
    [5] &quot;четырнадцать,&quot; &quot;я&quot;          &quot;поселился&quot;        &quot;на&quot;  &quot;улице&quot;      NA
    [6] &quot;широко&quot;        &quot;продолжали&quot; &quot;род.&quot;             NA    NA           NA

I have tried to just use `data.frame()` but that didn&#39;t work because the rows are of different length. I also tried `rbind.fill()` from the `plyr` package, but that function can only process matrices. 

I found some other questions here (that&#39;s where I got the `plyr` help from), but those were all about combining for instance two data frames of different size. 

Thanks for your help. 

How to convert a list consisting of vector of different lengths to a usable data frame in R?

I want to create a `std::set` with a custom comparison function. I could define it as a class with `operator()`, but I wanted to enjoy the ability to define a lambda where it is used, so I decided to define the lambda function in the initialization list of the constructor of the class which has the `std::set` as a member. But I can&#39;t get the type of the lambda. Before I proceed, here&#39;s an example:

    class Foo
    {
    private:
         std::set&lt;int, /*???*/&gt; numbers;
    public:
         Foo () : numbers ([](int x, int y)
                           {
                               return x &lt; y;
                           })
         {
         }
    };

I found two solutions after searching: one, using `std::function`. Just have the set comparison function type be `std::function&lt;bool (int, int)&gt;` and pass the lambda exactly like I did. The second solution is to write a make_set function, like `std::make_pair`.

SOLUTION 1:

    class Foo
    {
    private:
         std::set&lt;int, std::function&lt;bool (int, int)&gt; numbers;
    public:
         Foo () : numbers ([](int x, int y)
                           {
                               return x &lt; y;
                           })
         {
         }
    };

SOLUTION 2:

    template &lt;class Key, class Compare&gt;
    std::set&lt;Key, Compare&gt; make_set (Compare compare)
    {
         return std::set&lt;Key, Compare&gt; (compare);
    }

The question is, do I have a good reason to prefer one solution over the other? I prefer the first one because it makes use of standard features (make_set is not a standard function), but I wonder: does using `std::function` make the code (potentially) slower? I mean, does it lower the chance the compiler inlines the comparison function, or it should be smart enough to behave exactly the same like it would it was a lambda function type and not `std::function` (I know, in this case it can&#39;t be a lambda type, but you know, I&#39;m asking in general) ?

(I use GCC, but I&#39;d like to know what popular compilers do in general)

**SUMMARY, AFTER I GOT LOTS OF GREAT ANSWERS:**

If speed is critical, the best solution is to use an class with `operator()` aka functor. It&#39;s easiest for the compiler to optimize and avoid any indirections.

For easy maintenance and a better general-purpose solution, using C++11 features, use `std::function`. It&#39;s still fast (just a little bit slower than the functor, but it may be negligible) and you can use any function - `std::function`, lambda, any callable object.

There&#39;s also an option to use a function pointer, but if there&#39;s no speed issue I think `std::function` is better (if you use C++11).

There&#39;s an option to define the lambda function somewhere else, but then you gain nothing from the comparison function being a lambda expression, since you could as well make it a class with `operator()` and the location of definition wouldn&#39;t be the set construction anyway.

There are more ideas, such as using delegation. If you want a more thorough explanation of all solutions, read the answers :)

C++11 std::set lambda comparison function

I have two vectors:

    std::vector&lt;int&gt; v1, v2;
    
    // Filling v1
    ...

And now I need to copy `v1` to `v2`. Is there any reason to prefer 

`v2 = v1;`

to 

`std::copy (v1.begin(), v1.end(), v2.begin());`

(or vice versa)?

Copying std::vector: prefer assignment or std::copy?

I&#39;d like to build a `std::string` from a `std::vector&lt;std::string&gt;`.

I could use `std::stringsteam`, but imagine there is a shorter way:

    std::string string_from_vector(const std::vector&lt;std::string&gt; &amp;pieces) {
      std::stringstream ss;

      for(std::vector&lt;std::string&gt;::const_iterator itr = pieces.begin();
          itr != pieces.end();
          ++itr) {
        ss &lt;&lt; *itr;
      }

      return ss.str();
    }

How else might I do this?

How to construct a std::string from a std::vector&lt;string&gt;?

In C++, what is the type of a `std::map&lt;&gt;::iterator`?

We know that an object `it` of type `std::map&lt;A,B&gt;::iterator` has an overloaded `operator -&gt;` which returns a `std::pair&lt;A,B&gt;*`, and that the `std::pair&lt;&gt;` has a `first` and `second` member.

But, what do these two members correspond to, and why do we have to access the value stored in the map as `it-&gt;second`?

What does iterator-&gt;second mean?

ALL,

This question is a continuation of [this one][1].
I think that STL misses this functionality, but it just my IMHO.

Now, to the question.

Consider following code:

    class Foo
    {
    public:
        Foo();
        int paramA, paramB;
        std::string name;
    };

    struct Sorter
    {
        bool operator()(const Foo &amp;foo1, const Foo &amp;foo2) const
        {
             switch( paramSorter )
             {
                 case 1:
                     return foo1.paramA &lt; foo2.paramA;
                 case 2:
                     return foo1.paramB &lt; foo2.paramB;
                 default:
                     return foo1.name &lt; foo2.name;
             }
        }

        int paramSorter;
    };

    int main()
    {
        std::vector&lt;Foo&gt; foo;
        Sorter sorter;
        sorter.paramSorter = 0;
            // fill the vector
        std::sort( foo.begin(), foo.end(), sorter );
    }


At any given moment of time the vector can be re-sorted.
The class also have the getter methods which are used in the sorter structure.

What would be the most efficient way to insert a new element in the vector?

Situation I have is:

I have a grid (spreadsheet), that uses the sorted vector of a class. At any given time the vector can be re-sorted and the grid will display the sorted data accordingly.

Now I will need to insert a new element in the vector/grid.
I can insert, then re-sort and then re-display the whole grid, but this is very inefficient especially for the big grid.

Any help would be appreciated.

  [1]: https://stackoverflow.com/questions/15582504/is-there-a-sorted-container-in-stl







Content Type	Original Author	Original Content on Stackoverflow
Question	Aditya Sihag	View Question on Stackoverflow
Solution 1 - C++	juanchopanza	View Answer on Stackoverflow
Solution 2 - C++	hate-engine	View Answer on Stackoverflow

C++ std::vector emplace vs insert

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Why does IEnumerable<T>.ToList<T>() return List<T> instead of IList<T>?

How to continue in nested loops in Python

Attributions