Yes, that&#39;s what the standard requires it to be for `empty()` for any container.

&#167; 23.2.1 Table 96 of the C++11 standard says:

&lt;!-- language: none --&gt;

     +----------+---------------+----------------------+
     |Expression|  Return Type  | Operational Semantics|
     |----------|---------------|----------------------|
     |a.empty() |Convertible    |a.begin() == a.end()  |
     |          |to bool        |                      |
     |          |               |                      |
     +-------------------------------------------------+

**23.2.1 General container requirements**, specifically Table 96 **Container Requirements** has

&gt; `a.empty()` convertible to `bool`, operational semantics `a.begin() == a.end()`

Then

&gt; 6 `begin()` returns an iterator referring to the first element in the container. `end()` returns an iterator which
is the past-the-end value for the container. **If the container is empty, then `begin() == end();`**

(emphasis mine)


http://www.cplusplus.com/reference/vector/vector/end/

If the container is empty, end() is the same as begin().

Yes, that is true. Here is the [proof][1]. And, of course, `std::distance(a.begin(), a.end()) == 0` for an empty vector. 


  [1]: http://en.cppreference.com/w/cpp/container/vector/begin

I am a new comer to the android world and with a .NET background. I am trying to install the Android Studio but I am having a mismatch on Android.com about the JDK version required for developing Android applications.

From the [SDK web page][1] it states that **JDK 6** is required (under system requirements section). [Jim Wilson][2] also insist in [his course on Pluralsight][3] (which is quite new, from last May) that using version 7 with the Android SDK will create a lot of headache and makes it clear to only use JDK 6. 

Although in the [Android studio page][4] (Under installing step 2) they explain how to set an environment variable indicating the correct JDK location. In here they use a path of **JDK 7**

&gt; Select `Start menu &gt; Computer &gt; System Properties &gt; Advanced System Properties`. Then open `Advanced tab &gt; Environment Variables` and add a new system variable `JAVA_HOME` that points to your JDK folder, for example `C:\Program Files\Java\jdk1.7.0_21`.

I am pretty sure both the ADT &amp; Eclipse bundle and the Android Studio bundle are using the same SDK but now I am confused about which JDK version I need to install. My sole purpose is to avoid problems as much as possible while getting my first steps into the Android development.

Disclaimer: I am not related by any mean to Pluralsight. I am just a normal user following the courses.

  [1]: http://developer.android.com/sdk/index.html
  [2]: http://pluralsight.com/training/Authors/Details/jim-wilson
  [3]: http://www.pluralsight.com/training/Courses/TableOfContents/android-dotnet-developers-getting-started
  [4]: http://developer.android.com/sdk/installing/studio.html#Installing

Which JDK version (Language Level) is required for Android Studio?

How do you easily split a large PDF into two (or more) separate PDFs?

Say we have foo-bar.pdf, section foo is from page 1-12 and section bar is from page 13 till the end. I want foo-bar.pdf split into foo.pdf and bar.pdf.

Split a PDF in two

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 have long assumed that for any empty <code>std::vector</code> V, <code>V.begin() == V.end()</code>. 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?

In almost every post I see on SO, involving a `std::initializer_list`, people tend to pass a `std::initializer_list` by value. According to this article:

https://web.archive.org/web/20120707045924/cpp-next.com/archive/2009/08/want-speed-pass-by-value/

one should pass by value, if one wants to make a copy of the passed object. But copying a `std::initializer_list` is not a good idea, as
&gt; Copying a `std::initializer_list` does not copy the underlying objects.
&gt; The underlying array is not guaranteed to exist after the lifetime of
&gt; the original initializer list object has ended.

So why is an instance of it often passed by value and not by, say `const&amp;`, which guaranteed does not make a needless copy?

why is `std::initializer_list` often passed by value?

Looking for a way to implement a universal generic memoization function which will take a function and return the memoized version of the same?

Looking for something like @memo (from Norving&#39;s site)decorator in python.

&lt;!-- language: lang-python --&gt;

    def memo(f):
        table = {}
        def fmemo(*args):
            if args not in table:
                table[args] = f(*args)
            return table[args]
        fmemo.memo = table
        return fmemo

Going more general, is there a way to express generic and reusable decorators in C++, possibly using the new features of C++11?


Writing Universal memoization function in C++11

This:

    const char * terry = &quot;hello&quot;;
    cout&lt;&lt;terry;

prints `hello` instead of the memory address of the `&#39;h&#39;`. Why is this happening?


cout &lt;&lt; with char* argument prints string, not pointer value

In the following code, the first call to `foo` is ambiguous, and therefore fails to compile.

The second, with the added `+` before the lambda, resolves to the function pointer overload.

    #include &lt;functional&gt;
    
    void foo(std::function&lt;void()&gt; f) { f(); }
    void foo(void (*f)()) { f(); }
    
    int main ()
    {
        foo(  [](){} ); // ambiguous
        foo( +[](){} ); // not ambiguous (calls the function pointer overload)
    }

What is the `+` notation doing here?

Resolving ambiguous overload on function pointer and std::function for a lambda using + (unary plus)

Consider following code:

    #include &lt;iostream&gt;
    #include &lt;type_traits&gt;
    
    template &lt;typename T&gt;
    struct A {
        int val = 0;
    
        template &lt;class = typename std::enable_if&lt;T::value&gt;::type&gt;
        A(int n) : val(n) {};
        A(...) { }

        /* ... */
    };
    
    struct YES { constexpr static bool value = true; };
    struct NO { constexpr static bool value = false; };
    
    int main() {
        A&lt;YES&gt; y(10);
        A&lt;NO&gt; n;
        std::cout &lt;&lt; &quot;YES: &quot; &lt;&lt; y.val &lt;&lt; std::endl
                  &lt;&lt; &quot;NO:  &quot; &lt;&lt; n.val &lt;&lt; std::endl;
    }

I want to selectively define constructor A::A(int) only for some types using enable_if. For all other types there is default constructor A::A(...) which should be the default case for compiler when substitution fails. However this makes sense for me compiler (gcc version 4.9.0 20130714) is still complaining 

&gt; sfinae.cpp: In instantiation of &#39;struct A&lt;NO&gt;&#39;: sfinae.cpp:19:11:  
&gt; required from here sfinae.cpp:9:5: error: no type named &#39;type&#39; in  
&gt; &#39;struct std::enable_if&lt;false, void&gt;&#39;  
&gt;      A(int n) : val(n) {};  

Is something like this possible for constructor? Is this possible with another constructor(s) (copy-constructor and move-constructor)?

Select class constructor using enable_if

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


Is it good practice to use std::vector as a simple buffer?

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?

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.

Content Type	Original Author	Original Content on Stackoverflow
Question	OldPeculier	View Question on Stackoverflow
Solution 1 - C++	Rapptz	View Answer on Stackoverflow
Solution 2 - C++	juanchopanza	View Answer on Stackoverflow
Solution 3 - C++	Jiminion	View Answer on Stackoverflow
Solution 4 - C++	Ivan Smirnov	View Answer on Stackoverflow

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

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

Split a PDF in two

Which JDK version (Language Level) is required for Android Studio?

Attributions