You use `new` to perform dynamic allocation. It returns a pointer that points to the dynamically allocated object.

You have no reason to use `new`, since `A` is an automatic variable. You can simply initialise `A` using its constructor:

    vector&lt;vector&lt;int&gt; &gt; A(dimension, vector&lt;int&gt;(dimension));

Like this:

    #include &lt;vector&gt;

    // ...

    std::vector&lt;std::vector&lt;int&gt;&gt; A(dimension, std::vector&lt;int&gt;(dimension));

(Pre-C++11 you need to leave whitespace between the angled brackets.)

I&#39;m wondering what&#39;s the way to do work this snippet:

    //html
    &lt;div ng-app=&quot;app&quot;&gt;
        &lt;div ng-controller=&quot;AppCtrl&quot;&gt;
            &lt;a my-dir ng-repeat=&quot;user in users&quot;&gt;{{user.name}}&lt;/a&gt;
        &lt;/div&gt;
    &lt;/div&gt;

    //js
    var app = angular.module(&#39;app&#39;, []);
    app.controller(&quot;AppCtrl&quot;, function ($scope) {
        $scope.users = [{name:&#39;John&#39;,id:1},{name:&#39;anonymous&#39;}];
        $scope.fxn = function() {
            alert(&#39;It works&#39;);
        };
      
    })  
    app.directive(&quot;myDir&quot;, function ($compile) {
        return {
            link:function(scope,el){
                el.attr(&#39;ng-click&#39;,&#39;fxn()&#39;);
                //$compile(el)(scope); with this the script go mad 
            }
         };
    });


I know it&#39;s about the compile phase 
but I don&#39;t get the point so a short explanation would be 
very appreciate.


Angular directive how to add an attribute to the element?

I want to start using dplyr in place of ddply but I can&#39;t get a handle on how it works (I&#39;ve read the documentation). 

For example, why when I try to mutate() something does the &quot;group_by&quot; function not work as it&#39;s supposed to?

Looking at mtcars:

library(car)

Say I make a data.frame which is a summary of mtcars, grouped by &quot;cyl&quot; and &quot;gear&quot;:

    df1 &lt;- mtcars %.%
    			group_by(cyl, gear) %.%
    			summarise(
    				newvar = sum(wt)
    			)

Then say I want to further summarise this dataframe. With ddply, it&#39;d be straightforward, but when I try to do with with dplyr, it&#39;s not actually &quot;grouping by&quot;:

    df2 &lt;- df1 %.%
    			group_by(cyl) %.%
    			mutate(
    				newvar2 = newvar + 5
    			)

Still yields an ungrouped output:

      cyl gear newvar newvar2
    1   6    3  6.675  11.675
    2   4    4 19.025  24.025
    3   6    4 12.375  17.375
    4   6    5  2.770   7.770
    5   4    3  2.465   7.465
    6   8    3 49.249  54.249
    7   4    5  3.653   8.653
    8   8    5  6.740  11.740

Am I doing something wrong with the syntax?

____________________________

Edit:

If I were to do this with plyr and ddply:

    df1 &lt;- ddply(mtcars, .(cyl, gear), summarise, newvar = sum(wt))

and then to get the second df:

    df2 &lt;- ddply(df1, .(cyl), summarise, newvar2 = sum(newvar) + 5)

But that same approach, with sum(newvar) + 5 in the summarise() function doesn&#39;t work with dplyr... 


dplyr issues when using group_by(multiple variables)

If I have a NxN matrix

    vector&lt; vector&lt;int&gt; &gt; A;

How should I initialize it?

I&#39;ve tried with no success:

     A = new vector(dimension);
neither:

     A = new vector(dimension,vector&lt;int&gt;(dimension));

How to initialize a vector of vectors on a struct?

If I have a NxN matrix
<pre><code class="hljs language-arduino">vector&#x3C; vector&#x3C;int> > A;
</code></pre>
How should I initialize it?
I've tried with no success:
<pre><code class="hljs language-ini"> A = new vector(dimension);
</code></pre>
neither:
<pre><code class="hljs language-c"> A = new vector(dimension,vector&#x3C;int>(dimension));
</code></pre>

I was reading about [order of evaluation violations](http://en.cppreference.com/w/cpp/language/eval_order), and they give an example that puzzles me.

&gt;  1) If a side effect on a scalar object is un-sequenced relative to another side effect on the same scalar object, the behavior is undefined. 

&gt;     // snip
&gt;     f(i = -1, i = -1); // undefined behavior

In this context, `i` is a _scalar object_, which apparently means

&gt; Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2), std::nullptr_t, and cv-qualified versions of these types (3.9.3) are collectively called scalar types.

I don’t see how the statement is ambiguous in that case. It seems to me that regardless of if the first or second argument is evaluated first, `i` ends up as `-1`, and both arguments are also `-1`.

Can someone please clarify?

----------

## UPDATE
I really appreciate all the discussion. So far, I like [@harmic’s answer](https://stackoverflow.com/a/21671069) a lot since it exposes the pitfalls and intricacies of defining this statement in spite of how straight forward it looks at first glance. [@acheong87](https://stackoverflow.com/a/21677128) points out some issues that come up when using references, but I think that&#39;s orthogonal to the unsequenced side effects aspect of this question.

----------

## SUMMARY

Since this question got a ton of attention, I will summarize the main points/answers. First, allow me a small digression to point out that &quot;why&quot; can have closely related yet subtly different meanings, namely &quot;for what _cause_&quot;, &quot;for what _reason_&quot;, and &quot;for what _purpose_&quot;. I will group the answers by which of those meanings of &quot;why&quot; they addressed.

### for what cause

The main answer here comes from [Paul Draper](https://stackoverflow.com/a/21670570/1072468), with [Martin J](https://stackoverflow.com/a/21670751/1072468) contributing a similar but not as extensive answer. Paul Draper&#39;s answer boils down to

&gt; It is undefined behavior because it is not defined what the behavior is.

The answer is overall very good in terms of explaining what the C++ standard says. It also addresses some related cases of UB such as `f(++i, ++i);` and `f(i=1, i=-1);`. In the first of the related cases, it&#39;s not clear if the first argument should be `i+1` and the second `i+2` or vice versa; in the second, it&#39;s not clear if `i` should be 1 or -1 after the function call. Both of these cases are UB because they fall under the following rule:

&gt; If a side effect on a scalar object is unsequenced relative to another side effect on the same scalar object, the behavior is undefined.

Therefore, `f(i=-1, i=-1)` is also UB since it falls under the same rule, despite that the intention of the programmer is (IMHO) obvious and unambiguous.

Paul Draper also makes it explicit in his conclusion that

&gt; Could it have been defined behavior? Yes. Was it defined? No.

which brings us to the question of &quot;for what reason/purpose was `f(i=-1, i=-1)` left as undefined behavior?&quot;

### for what reason / purpose

Although there are some oversights (maybe careless) in the C++ standard, many omissions are well-reasoned and serve a specific purpose. Although I am aware that the purpose is often either &quot;make the compiler-writer&#39;s job easier&quot;, or &quot;faster code&quot;, **I was mainly interested to know if there is a good reason leave** `f(i=-1, i=-1)` **as UB.**

[harmic](https://stackoverflow.com/a/21671069/1072468) and [supercat](https://stackoverflow.com/a/21683253/1072468) provide the main answers that provide a _reason_ for the UB. Harmic points out that an optimizing compiler that might break up the ostensibly atomic assignment operations into multiple machine instructions, and that it might further interleave those instructions for optimal speed. This could lead to some very surprising results: `i` ends up as -2 in his scenario! Thus, harmic demonstrates how assigning the _same value_ to a variable more than once can have ill effects if the operations are unsequenced.

supercat provides a related exposition of the pitfalls of trying to get `f(i=-1, i=-1)` to do what it looks like it ought to do. He points out that on some architectures, there are hard restrictions against multiple simultaneous writes to the same memory address. A compiler could have a hard time catching this if we were dealing with something less trivial than `f(i=-1, i=-1)`.

[davidf](https://stackoverflow.com/a/21708746/1072468) also provides an example of interleaving instructions very similar to harmic&#39;s.

Although each of harmic&#39;s, supercat&#39;s and davidf&#39; examples are somewhat contrived, taken together they still serve to provide a tangible reason why `f(i=-1, i=-1)` should be undefined behavior.

I accepted harmic&#39;s answer because it did the best job of addressing all meanings of why, even though Paul Draper&#39;s answer addressed the &quot;for what cause&quot; portion better.

### other answers
[JohnB](https://stackoverflow.com/a/21679403/1072468) points out that if we consider overloaded assignment operators (instead of just plain scalars), then we can run into trouble as well.


Why is f(i = -1, i = -1) undefined behavior?

[This answer](https://stackoverflow.com/a/10319672/1805388) gives a nice high-level overview of short string optimization (SSO). However, I would like to know in more detail how it works in practice, specifically in the libc++ implementation:

 - How short does the string have to be in order to qualify for SSO?
   Does this depend on the target architecture?
   
 - How does the implementation distinguish between short and long
   strings when accessing the string data? Is it as simple as `m_size &lt;= 16` or is it a flag that is part of some other member variable? (I
   imagine that `m_size` or part of it might also be used to store
   string data).

I asked this question specifically for libc++ because I know that it uses SSO, this is even mentioned on the [libc++ home page](http://libcxx.llvm.org/).

Here are some observations after looking at [the source](http://llvm.org/svn/llvm-project/libcxx/trunk/include/string):

libc++ can be compiled with two slightly different memory layouts for the string class, this is governed by the `_LIBCPP_ALTERNATE_STRING_LAYOUT` flag. Both of the layouts also distinguish between little-endian and big-endian machines which leaves us with a total of 4 different variants. I will assume the &quot;normal&quot; layout and little-endian in what follows.


Assuming further that `size_type` is 4 bytes and that `value_type` is 1 byte, this is what the first 4 bytes of a string would look like in memory:

    // short string: (s)ize and 3 bytes of char (d)ata
    sssssss0;dddddddd;dddddddd;dddddddd
           ^- is_long = 0

    // long string: (c)apacity
    ccccccc1;cccccccc;cccccccc;cccccccc
           ^- is_long = 1

Since the size of the short string is in the upper 7 bits, it needs to be shifted when accessing it:

    size_type __get_short_size() const {
        return __r_.first().__s.__size_ &gt;&gt; 1;
    }

Similarly, the getter and setter for the capacity of a long string uses `__long_mask` to work around the `is_long` bit.

I am still looking for an answer to my first question, i.e. what value would `__min_cap`, the capacity of short strings, take for different architectures?

**Other standard library implementations**

[This answer](https://stackoverflow.com/a/28003328/1805388) gives a nice overview of `std::string` memory layouts in other standard library implementations.

What are the mechanics of short string optimization in libc++?

Had some issues in my code recently surrounding what I now know of as a Circular dependency. In short there are two classes, Player and Ball, which both need to use information from the other. Both at some point in the code will be passed a reference of the other (from another class that will include both .h files).

After reading up on it, I removed the #include.h files from each one and went with forward declaration. This solved the issue of being able to declare the classes in eachother, but I&#39;m now left with an &quot;Incomplete type error&quot; when trying to access a passed reference to the object. There seem to be a few similar examples around, though often mixed with more complex code and hard to narrow down to the basics.

I&#39;ve rewritten the code in it&#39;s simplest form (a skeleton essentially).

Ball.h:

    class Player;
    
    class Ball {
    public:
    	Player&amp; PlayerB;
    	float ballPosX = 800;
    private:
    
    };

Player.h:

    class Ball;
    
    class Player {
    public:
    	void doSomething(Ball&amp; ball);
    private:
    };

Player.cpp:

    #include &quot;Player.h&quot;
    
    void Player::doSomething(Ball&amp; ball) {
    	ball.ballPosX += 10;                   // incomplete type error occurs here.
    }

Any help understanding why this is the case would be greatly appreciated :)


c++ &quot;Incomplete type not allowed&quot; error accessing class reference information (Circular dependency with forward declaration)

I created a simple **bidirectional map** class that works by internally storing two `std::map` instances, with opposite key/value types, and providing an user-friendly interface:

    template&lt;class T1, class T2&gt; class Bimap
    {
        std::map&lt;T1, T2&gt; map1;
        std::map&lt;T2, T1&gt; map2;
        // ...
    };

* Is there a more efficient method of implementing a bidirectional map that doesn&#39;t require twice the memory?

* How is a bimap usually implemented?

---

*EDIT:*

* Should bimap element be mutable or immutable? *(Changing one element in `map1` should change the key in `map2`, but keys are const and that&#39;s impossible - what&#39;s the solution?)*
 
* Ownership of elements is also another problem: when an user inserts a key-value pair in the bimap, the bimap should make a copy of that key-value pair and store it, then the internal second map (with inverted key/value) should not copy but point to the original pair. How can this be achieved?

---

*EDIT 2:* 

[I&#39;ve posted a possible implementation I made on Code Review.](https://codereview.stackexchange.com/questions/42427/bidirectional-map-based-on-memory-manipulation-c11)

Is there a more efficient implementation for a bidirectional map?

Can you explain to me the difference between returning value, reference to value, and const reference to value?

**Value:**

    Vector2D operator += (const Vector2D&amp; vector)
    {
        this-&gt;x += vector.x;
        this-&gt;y += vector.y;
        return *this;
    }
**Not-const reference:**

    Vector2D&amp; operator += (const Vector2D&amp; vector)
    {
        this-&gt;x += vector.x;
        this-&gt;y += vector.y;
        return *this;
    }
**Const reference:**

    const Vector2D&amp; operator += (const Vector2D&amp; vector)
    {
        this-&gt;x += vector.x;
        this-&gt;y += vector.y;
        return *this;
    }

What is the benefit of this? I understand the sense behind const reference passing to function as you want to make sure not to modify this value on which reference is pointing to inside a the function. But I&#39;m confused by the meaning of returning const reference. Why returning of reference is better than returning of value, and why returning of const reference is better than returning of not-const reference?


C++ Return value, reference, const reference

I&#39;m trying to learn R and I can&#39;t figure out how to append to a list.

If this were Python I would . . .
 
    #Python
    vector = []
    values = [&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;,&#39;e&#39;,&#39;f&#39;,&#39;g&#39;]
    
    for i in range(0,len(values)):
        vector.append(values[i])

How do you do this in R?

    #R Programming
    &gt; vector = c()
    &gt; values = c(&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;,&#39;e&#39;,&#39;f&#39;,&#39;g&#39;)
    &gt; for (i in 1:length(values))
    + #append value[i] to empty vector



Append value to empty vector in R?

Please consider this code. I have seen this type of code several times. `words` is a local vector. How is it possible to return it from a function?

Can we guarantee it will not die?

     std::vector&lt;std::string&gt; read_file(const std::string&amp; path)
     {
        std::ifstream file(&quot;E:\\names.txt&quot;);

        if (!file.is_open())
        {
            std::cerr &lt;&lt; &quot;Unable to open file&quot; &lt;&lt; &quot;\n&quot;;
            std::exit(-1);
        }

        std::vector&lt;string&gt; words;//this vector will be returned
        std::string token;

        while (std::getline(file, token, &#39;,&#39;))
        {
            words.push_back(token);
        }

        return words;
    }



Why is it OK to return a &#39;vector&#39; from a function?

I would like to merge 2 vectors this way :

    a = c(1,2,3)
    b = c(11,12,13)
    merged vector : c(1,11,2,12,3,13)

How could I do it ?

How to merge 2 vectors alternating indexes?

As far as I can tell, anywhere `std::back_inserter` works in an STL algorithm, you could pass an `std::inserter` constructed with `.end()` instead:

    std::copy(l.begin(), l.end(), std::back_inserter(dest_list));
    std::copy(l.begin(), l.end(), std::inserter(dest_list, dest_list.end()));

AND, unlike `back_inserter`, as far as I can tell `inserter` works for ANY STL container!! I tried it successfully for `std::vector`, `std::list`, `std::map`, `std::unordered_map` before coming here surprised.


I thought that maybe it&#39;s because `push_back` could be faster for some structures than `insert(.end())`, but I&#39;m not sure...

That doesn&#39;t seem to be the case for `std::list` (makes sense):

    // Copying 10,000,000 element-list with std::copy. Did it twice w/ switched order just in case that matters.
    Profiling complete (884.666 millis total run-time): inserter(.end())
    Profiling complete (643.798 millis total run-time): back_inserter
    Profiling complete (644.060 millis total run-time): back_inserter
    Profiling complete (623.151 millis total run-time): inserter(.end())

But it does slightly for `std::vector`, though I&#39;m not really sure why?:

    // Copying 10,000,000 element-vector with std::copy.
    Profiling complete (985.754 millis total run-time): inserter(.end())
    Profiling complete (746.819 millis total run-time): back_inserter
    Profiling complete (745.476 millis total run-time): back_inserter
    Profiling complete (739.774 millis total run-time): inserter(.end())

I guess in a vector there is slightly more overhead figuring out where the iterator is and then putting an element there vs just arr[count++]. Maybe it&#39;s that?


But still, is that the main reason?

My followup question, I guess, is &quot;Is it okay to write `std::inserter(container, container.end())` for a templated function and expect it to work for (almost) any STL container?&quot;

&lt;hr&gt;

I updated the numbers after moving to a standard compiler. Here is my compiler&#39;s details:
&lt;br&gt;gcc version 4.8.2 (Ubuntu 4.8.2-19ubuntu1) &lt;br&gt;
Target: x86_64-linux-gnu

My build command:

    g++ -O0 -std=c++11 algo_test.cc



&lt;hr&gt;

I think [this question asks the second half of my question][1], namely, &quot;Can I write a templated function that uses `std::inserter(container, container.end())` and expect it to work for almost every container?&quot;

The answer there was &quot;Yes, for every container except for `std::forward_list`.&quot; But based on the discussion in the comments below and in [user2746253][2]&#39;s answer, it sounds like I should be aware that this would be slower for `std::vector` than using `std::back_inserter`...

Therefore, I might want to specialize my template for containers using `RandomAccessIterator`s to use `back_inserter` instead. Does that make sense? Thanks.


  [1]: https://stackoverflow.com/q/23360656/751061
  [2]: https://stackoverflow.com/users/2746253/user2746253

What&#39;s the benefit of std::back_inserter over std::inserter?

Background
--
I&#39;ve noticed that Android now supports some kind of vector drawing, via a class called &quot;[**VectorDrawable**][1]&quot; (and also [**AnimatedVectorDrawable**][2], BTW). I&#39;ve found about it by looking at what&#39;s new on [**Android-Studio**][3].

I wonder if this would be the end of having to put multiple files into multiple folders (`mdpi`, `hdpi`, `xhdpi`, etc). That would be great and might minimize apps sizes on some cases.

The questions
--
I&#39;d like to ask a few questions regarding this new class:

1. Is it possible to use it in older Android versions, maybe via a library of even the support library of Google?

2. I&#39;m not familiar with how it works, but can Lollipop handle SVG files? Can it do anything that is achievable on SVG files?

3. Is there any sample/tutorial/video of using it, other than the documentation I&#39;ve found?

  [1]: http://developer.android.com/reference/android/graphics/drawable/VectorDrawable.html
  [2]: https://developer.android.com/reference/android/graphics/drawable/AnimatedVectorDrawable.html
  [3]: https://sites.google.com/a/android.com/tools/recent/androidstudio0814released


Content Type	Original Author	Original Content on Stackoverflow
Question	anat0lius	View Question on Stackoverflow
Solution 1 - C++	Joseph Mansfield	View Answer on Stackoverflow
Solution 2 - C++	Kerrek SB	View Answer on Stackoverflow

How to initialize a vector of vectors on a struct?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

dplyr issues when using group_by(multiple variables)

Angular directive how to add an attribute to the element?

Attributions