`size_type` is a *(static) member type* of the type `vector&lt;int&gt;`. Usually, it is a `typedef` for `std::size_t`, which itself is usually a `typedef` for `unsigned int` or `unsigned long long`.

I would read it as &quot;declare x as a variable of a type suitable for holding the size of a vector&quot;. The vector defines its own type for its length, and it&#39;s always cleanest to use that if possible, rather than &quot;guessing&quot; and using &lt;code&gt;int&lt;/code&gt;, &lt;code&gt;unsigned int&lt;/code&gt;, &lt;code&gt;long&lt;/code&gt;, &lt;code&gt;unsigned long&lt;/code&gt; or &lt;code&gt;size_t&lt;/code&gt; etc directly as you&#39;d otherwise need to do.


vector is a template

so the `vector` type templated with `int` has a member `typedef` called `size_type`. `x` is defined as a variable of that type.



&gt; Different implementations use different types to represent sizes, so
&gt; we cannot write the appropriate type directly and remain
&gt; implementation-independent. For that reason, it is good programming
&gt; practice to use the size_type that the library defines to represent
&gt; container sizes.

\- Accelerated C++ by Andrew Koenig and Barbara E. Moo

It&#39;s really a simple problem : 

I&#39;m programming a Go program. Should I represent the board with a `QVector&lt;int&gt;` or a `QVector&lt;Player&gt;` where

    enum Player
    {
        EMPTY = 0,
        BLACK = 1,
        WHITE = 2
    };

I guess that of course, using Player instead of integers will be slower. But I wonder how much more, because I believe that using `enum` is better coding.

I&#39;ve done a few tests regarding assigning and comparing Players (as opposed to `int`)

    QVector&lt;int&gt; vec;
    vec.resize(10000000);
    int size = vec.size();


    for(int i =0; i&lt;size; ++i)
    {
        vec[i] = 0;
    }


    for(int i =0; i&lt;size; ++i)
    {
        bool b = (vec[i] == 1);
    }


    QVector&lt;Player&gt; vec2;
    vec2.resize(10000000);
    int size = vec2.size();


    for(int i =0; i&lt;size; ++i)
    {
        vec2[i] = EMPTY;
    }


    for(int i =0; i&lt;size; ++i)
    {
        bool b = (vec2[i] == BLACK);
    }

Basically, it&#39;s only 10% slower. Is there anything else I should know before continuing?

Thanks!

Edit : The 10% difference is not a figment of my imagination, it seems to be specific to Qt and QVector. When I use std::vector, the speed is the same

Are C++ enums slower to use than integers?

What are the different ways I can remove characters from a string in JavaScript?

Remove characters from a string

What is meant by this C++ statement?

    vector&lt;int&gt;::size_type x;

And, what is the use of the scope operator `::` here? In other words, how do we read this statement in English?

For example, for `X::x(){...}`, we say that `x()` is a `member function` of `class X`.

vector&lt;int&gt;::size_type in C++

What is meant by this C++ statement?
<pre><code class="hljs language-arduino">vector&#x3C;int>::size_type x;
</code></pre>
And, what is the use of the scope operator <code>::</code> here? In other words, how do we read this statement in English?
For example, for <code>X::x(){...}</code>, we say that <code>x()</code> is a <code>member function</code> of <code>class X</code>.

I would like to have a single template that once and for all takes care of pretty-printing all STL containers via `operator&lt;&lt;`. In pseudo code, I&#39;m looking for something like this:

    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)
    {
        o &lt;&lt; open;
        // for (typename C::const_iterator i = x.begin(); i != x.end(); i++) /* Old-school */
        for (auto i = x.begin(); i != x.end(); i++)
        {
            if (i != x.begin()) o &lt;&lt; delim;
            o &lt;&lt; *i;
        }
        o &lt;&lt; close;
        return o;
    }

Now I&#39;ve seen plenty of template magic here on SO that I never thought possible, so I&#39;m wondering if anyone can suggest something that would match all containers `C&lt;T&gt;`. Maybe something trait-ish that can figure out if something has the necessary iterator?



Pretty-print C++ STL containers

Question is in the title really; I&#39;m sure there is something logical, but for now I&#39;m stumped!

Why are bitwise shifts (&lt;&lt; and &gt;&gt;) used for cout and cin?

    class Address {
          int i ;
          char b;
          string c;
          public:
               void showMap ( void ) ;
    };

    void Address :: showMap ( void ) {
                cout &lt;&lt; &quot;address of int    :&quot; &lt;&lt; &amp;i &lt;&lt; endl ;
                cout &lt;&lt; &quot;address of char   :&quot; &lt;&lt; &amp;b &lt;&lt; endl ;
                cout &lt;&lt; &quot;address of string :&quot; &lt;&lt; &amp;c &lt;&lt; endl ;
    }

The output is:

             address of int    :  something
             address of char   :     // nothing, blank area, that is nothing displayed
             address of string :  something 
        

**Why?**

Another interesting thing: if int, char, string is in public, then the output is

      ... int    :  something 
      ... char   :   
      ... string :  something_2

`something_2 - something` is always equal to 8. **Why? (not 9)**

Why is address of char data not displayed?

While reading the documentation for boost::test, I came across the term &quot;free function&quot;. What I understand is that a free function is any function that doesn&#39;t return anything (Its return type is void). But after reading further it seems that free functions also don&#39;t take any arguments. But I am not sure. These all are my assumptions. So could anybody define free function?

What is the meaning of the term &quot;free function&quot; in C++?

I have a `vector&lt;data&gt; info` where `data` is defined as:

    struct data{
        string word;
        int number;
    };

I need to sort `info` by the length of the word strings. Is there a quick and simple way to do it?

sorting a vector of structs

When I try to include any C++ class like vector in my Android NDK project (using NDK r5b, the latest), I get an error like the following...

`Compile++ thumb  : test-libstl &lt;= test-libstl.cpp
/Users/nitrex88/Desktop/Programming/EclipseProjects/STLTest/jni/test-libstl.cpp:3:18: error: vector: No such file or directory`

Other people who reported this issue online have claimed success by adding

`APP_STL := stlport_static`

to their Application.mk file. I have done this as well as tried every other possible value for APP_STL. I&#39;ve cleaned to project, ran ndk-build clean, deleted the obj and libs folders, and still when I compile it cannot find the vector class. I&#39;ve been working on this for a number of weeks now (since NDK r5 came out) and would really appreciate if someone has any advice. Thanks!


Can&#39;t include C++ headers like vector in Android NDK

I am running into issues trying to use large objects in R. For example:

    &gt; memory.limit(4000)
    &gt; a = matrix(NA, 1500000, 60)
    &gt; a = matrix(NA, 2500000, 60)
    &gt; a = matrix(NA, 3500000, 60)
    Error: cannot allocate vector of size 801.1 Mb
    &gt; a = matrix(NA, 2500000, 60)
    Error: cannot allocate vector of size 572.2 Mb # Can&#39;t go smaller anymore
    &gt; rm(list=ls(all=TRUE))
    &gt; a = matrix(NA, 3500000, 60) # Now it works
    &gt; b = matrix(NA, 3500000, 60)
    Error: cannot allocate vector of size 801.1 Mb # But that is all there is room for

I understand that this is related to the difficulty of obtaining contiguous blocks of memory (from [here][1]):

&gt; Error messages beginning cannot
&gt; allocate vector of size indicate a
&gt; failure to obtain memory, either
&gt; because the size exceeded the
&gt; address-space limit for a process or,
&gt; more likely, because the system was
&gt; unable to provide the memory. Note
&gt; that on a 32-bit build there may well
&gt; be enough free memory available, but
&gt; not a large enough contiguous block of
&gt; address space into which to map it.

How can I get around this? My main difficulty is that I get to a certain point in my script and R can&#39;t allocate 200-300 Mb for an object... I can&#39;t really pre-allocate the block because I need the memory for other processing. This happens even when I dilligently remove unneeded objects.

EDIT: Yes, sorry: Windows XP SP3, 4Gb RAM, R 2.12.0:

    &gt; sessionInfo()
    R version 2.12.0 (2010-10-15)
    Platform: i386-pc-mingw32/i386 (32-bit)
    
    locale:
    [1] LC_COLLATE=English_Caribbean.1252  LC_CTYPE=English_Caribbean.1252   
    [3] LC_MONETARY=English_Caribbean.1252 LC_NUMERIC=C                      
    [5] LC_TIME=English_Caribbean.1252    
    
    attached base packages:
    [1] stats     graphics  grDevices utils     datasets  methods   base
    
[1]: http://stat.ethz.ch/R-manual/R-patched/library/base/html/Memory-limits.html

R memory management / cannot allocate vector of size n Mb

What I need is a signed angle of rotation between two vectors Va and Vb lying within the same 3D plane and having the same origin knowing that:

1. The plane contatining both vectors is an arbitrary and is not parallel to XY or any other of cardinal planes
2. Vn - is a plane normal
3. Both vectors along with the normal have the same origin O = { 0, 0, 0 }
4. Va - is a reference for measuring the left handed rotation at Vn

The angle should be measured in such a way so if the plane would be XY plane the Va would stand for X axis unit vector of it.

I guess I should perform a kind of coordinate space transformation by using the Va as the X-axis and the cross product of Vb and Vn as the Y-axis and then just using some 2d method like with atan2() or something. Any ideas? Formulas?

Signed angle between two 3D vectors with same origin within the same plane

I understand from the answer to [this question][1]  that values of global/static uninitialized int will be 0.   The answer to [this one][2] says that for vectors, the default constructor for the object type will be called.


I am unable to figure out - what happens when   I have  `vector&lt;int&gt; v(10)` in a local function. What is the default constructor for *int*?  What if I have `vector&lt;int&gt; v(10)` declared globally?


What I am seeing is that  `vector&lt;int&gt; v(10)` in a local function is resulting in variables being 0 - but I am not sure if that is just because of my compiler or is the fixed expected behaviour.



  [1]: https://stackoverflow.com/questions/1597405/what-happens-to-a-declared-uninitialized-variable-in-c-does-it-have-a-value
  [2]: https://stackoverflow.com/questions/1787856/what-is-the-element-value-in-an-uninitialized-vector

Content Type	Original Author	Original Content on Stackoverflow
Question	Simplicity	View Question on Stackoverflow
Solution 1 - C++	fredoverflow	View Answer on Stackoverflow
Solution 2 - C++	unwind	View Answer on Stackoverflow
Solution 3 - C++	T33C	View Answer on Stackoverflow
Solution 4 - C++	Puddle	View Answer on Stackoverflow

vector<int>::size_type in C++

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

Remove characters from a string

Are C++ enums slower to use than integers?

Attributions