&gt; Do they mean the same thing?

[Universal reference](https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers) was a term Scott Meyers coined to describe the concept of taking an rvalue reference to a cv-unqualified template parameter, which can then be deduced as either a value or an lvalue reference. 

At the time the C++ standard didn&#39;t have a special term for this, which was an oversight in C++11 and makes it hard to teach. This oversight was remedied by  [N4164](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4164.pdf), which added the following definition to [\[temp.deduct\]](http://eel.is/c++draft/temp.deduct#call-3):

&gt;  A *forwarding reference* is an rvalue reference to a cv-unqualified template parameter. If `P` is a forwarding reference and the argument is an lvalue, the type “lvalue reference to A” is used in place of A for type deduction.

Hence, the two mean the same thing, and the current C++ standard term is forwarding reference. The paper itself articulates why &quot;forwarding reference&quot; is a better term than &quot;universal reference.&quot;

&gt; Is it only a forwarding reference if the function body calls `std::forward`?

Nope, what you do with a forwarding reference is irrelevant to the name. The concept forwarding reference simply refers to how the type `T` is deduced in:

    template &lt;class T&gt; void foo(T&amp;&amp; ); // &lt;== 

It does not need to be subsequently forwarded .

Unfortunately, it&#39;s confusing, but they are nothing more than two names for the same thing.  
Universal reference was proposed (I guess) by Meyers far ago (see [here](https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers) as an example).  
Forwarding reference is picked up directly from the _standardese_. That&#39;s all.

Google Chrome started implementing [Blocking the load of cross-origin, parser-blocking scripts inserted via document.write in the main frame](https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/HGh92uMX_kE) on slow networks, which causes the following error:

&gt; A Parser-blocking, cross-origin script, http://example.org/script.js, is invoked via document.write. This may be blocked by the browser if the device has poor network connectivity.

However, my web page requires loading a third party script synchronously, using `document.write(&#39;&lt;script src=&quot;...&quot;&gt;&lt;/script&gt;&#39;)`. How to circumvent that blockade?

More about that change:

 - [Design document](https://docs.google.com/document/d/1dMJRQKTw75ZNdknP3pirSBH3koPl_IWHnxlcBuu4t_c/edit)
 - [Longer document](https://docs.google.com/document/d/1AtS83d9joGj-xmt_pZB4Uvvn_9d1aEReRg0rI_5runw/edit)
 - [Web Incubator CG issue](https://github.com/WICG/interventions/issues/17)
 - [Chrome Issue](https://bugs.chromium.org/p/chromium/issues/detail?id=640844)

A Parser-blocking, cross-origin script is invoked via document.write - how to circumvent it?

I&#39;m starting in swift and opening a project created using swift2 from xcode 8 beta, the `private` modifier were changed to `fileprivate`. what does this keyword means? and how is different from `private` ?

What does &#39;fileprivate&#39; keyword means in Swift?

An argument to this function will bind to an rvalue reference:  

    void f(int &amp;&amp; i);

However, an argument to this function will bind to either an rvalue or an lvalue reference:  

    template &lt;typename T&gt;  
    void f(T &amp;&amp; t);
I&#39;ve often heard this referred to as a universal reference.    
I&#39;ve also heard it been called a forwarding reference.  
Do they mean the same thing?   
Is it only a forwarding reference if the function body calls `std::forward`?

Is there a difference between universal references and forwarding references?

An argument to this function will bind to an rvalue reference:
<pre><code class="hljs language-arduino">void f(int &#x26;&#x26; i);
</code></pre>
However, an argument to this function will bind to either an rvalue or an lvalue reference:
<pre><code class="hljs language-arduino">template &#x3C;typename T> 
void f(T &#x26;&#x26; t);
</code></pre>
I've often heard this referred to as a universal reference. 
I've also heard it been called a forwarding reference. 
Do they mean the same thing? 
Is it only a forwarding reference if the function body calls <code>std::forward</code>?

What is the actual difference between `CMake` and `NDK` build in android studio project. I already went through google documentation but the concept is not clear yet. As per google documentation:

 **The Android Native Development Kit (NDK):** a toolset that allows you
  to use C and C++ code with Android, and provides platform libraries
  that allow you to manage native activities and access the physical device
  components, such as sensors and touch input.

 **CMake:** an external build tool that works alongside Gradle to build
  your native library. You do not need this component if you only plan
  to use ndk-build.

Can anyone has a better explanation with an example when we need to use what?

Difference between CMake and NDK-build in android studio project

I can&#39;t get the additional libraries I am working with to link into my project properly.

I am using CLion, which uses cmake to build it&#39;s projects. I am trying to use several libraries in conjunction with OpenGL to texture some objects. I initially built it in Visual Studio, because I couldn&#39;t ever figure out how to get cmake to work with Clion. However, now that the code is all working (in Visual Studio, anyways), I want to be able to use CLion for it, because that is my preferred IDE.

I am still new to cmake, and I don&#39;t understand what I am doing wrong with my `CMakeLists.txt`. Here is what I have:

    cmake_minimum_required(VERSION 3.3)
    project(texture_mapping)
    find_package(OpenGL REQUIRED)
    link_directories(${OPENGL_gl_LIBRARY})
    
    set(CMAKE_CXX_FLAGS &quot;${CMAKE_CXX_FLAGS} -std=c++11&quot;)
    
    set(SOURCE_FILES main.cpp camera.h display.h display.cpp mesh.cpp mesh.h obj_loader.cpp obj_loader.h shader.cpp shader.h stb_image.c stb_image.h texture.cpp texture.h transform.h)
    
    link_directories(texture_mapping ${PROJECT_SOURCE_DIR}/lib)
    
    add_executable(texture_mapping ${SOURCE_FILES})
    
    target_include_directories(texture_mapping PUBLIC ${PROJECT_SOURCE_DIR}/include)
    target_link_libraries(texture_mapping SDL2 SDL2main SDL2test glew32 glew32s ${OPENGL_gl_LIBRARY})

I tweaked it until it didn&#39;t give me any more errors in CLion, but the header files are still not recognized in my code.

Here is the structure of my project:  
[![project structure][1]][1]

So, I put all of the libraries I needed, but it doesn&#39;t appear to be recognizing them in the code. Clion recognizes them in the project (they aren&#39;t appearing red with errors), but when it is built (when I attempt to run it in CLion), I get these errors:

    CMakeFiles\texture_mapping.dir/objects.a(mesh.cpp.obj): In function `ZN4MeshD2Ev&#39;:
    ...texture-mapping/mesh.cpp:30: undefined reference to `_imp____glewDeleteVertexArrays&#39;
    CMakeFiles\texture_mapping.dir/objects.a(mesh.cpp.obj): In function `ZN4Mesh8InitMeshERK12IndexedModel&#39;:
    ...texture-mapping/mesh.cpp:36: undefined reference to `_imp____glewGenVertexArrays&#39;
    ...texture-mapping/mesh.cpp:37: undefined reference to `_imp____glewBindVertexArray&#39;
    ...texture-mapping/mesh.cpp:39: undefined reference to `_imp____glewGenBuffers&#39;
    ...texture-mapping/mesh.cpp:40: undefined reference to `_imp____glewBindBuffer&#39;
    ...texture-mapping/mesh.cpp:41: undefined reference to `_imp____glewBufferData&#39;
    ...texture-mapping/mesh.cpp:43: undefined reference to `_imp____glewEnableVertexAttribArray&#39;
    ...texture-mapping/mesh.cpp:44: undefined reference to `_imp____glewVertexAttribPointer&#39;
    ...texture-mapping/mesh.cpp:46: undefined reference to `_imp____glewBindBuffer&#39;
    ...texture-mapping/mesh.cpp:47: undefined reference to `_imp____glewBufferData&#39;
    ...texture-mapping/mesh.cpp:49: undefined reference to `_imp____glewEnableVertexAttribArray&#39;
    ...texture-mapping/mesh.cpp:50: undefined reference to `_imp____glewVertexAttribPointer&#39;
    ...texture-mapping/mesh.cpp:52: undefined reference to `_imp____glewBindBuffer&#39;
    ...texture-mapping/mesh.cpp:53: undefined reference to `_imp____glewBufferData&#39;
    ...texture-mapping/mesh.cpp:55: undefined reference to `_imp____glewBindVertexArray&#39;
    ...texture-mapping/mesh.cpp:56: undefined reference to `_imp____glewBindVertexArray&#39;
    CMakeFiles\texture_mapping.dir/objects.a(mesh.cpp.obj): In function `ZN4Mesh4DrawEv&#39;:
    ...texture-mapping/mesh.cpp:61: undefined reference to `_imp____glewBindVertexArray&#39;
    ...texture-mapping/mesh.cpp:65: undefined reference to `_imp____glewBindVertexArray&#39;
    CMakeFiles\texture_mapping.dir/objects.a(shader.cpp.obj): In function `ZN6ShaderC2ERKSs&#39;:
    ...texture-mapping/shader.cpp:5: undefined reference to `_imp____glewCreateProgram&#39;
    ...texture-mapping/shader.cpp:11: undefined reference to `_imp____glewAttachShader&#39;
    ...texture-mapping/shader.cpp:14: undefined reference to `_imp____glewBindAttribLocation&#39;
    ...texture-mapping/shader.cpp:15: undefined reference to `_imp____glewBindAttribLocation&#39;
    ...texture-mapping/shader.cpp:17: undefined reference to `_imp____glewLinkProgram&#39;
    ...texture-mapping/shader.cpp:20: undefined reference to `_imp____glewValidateProgram&#39;
    ...texture-mapping/shader.cpp:23: undefined reference to `_imp____glewGetUniformLocation&#39;
    CMakeFiles\texture_mapping.dir/objects.a(shader.cpp.obj): In function `ZN6Shader4BindEv&#39;:
    ...texture-mapping/shader.cpp:28: undefined reference to `_imp____glewUseProgram&#39;
    CMakeFiles\texture_mapping.dir/objects.a(shader.cpp.obj): In function `ZN6Shader6UpdateERK9TransformRK6Camera&#39;:
    ...texture-mapping/shader.cpp:35: undefined reference to `_imp____glewUniformMatrix4fv&#39;
    CMakeFiles\texture_mapping.dir/objects.a(shader.cpp.obj): In function `ZN6ShaderD2Ev&#39;:
    ...texture-mapping/shader.cpp:42: undefined reference to `_imp____glewDetachShader&#39;
    ...texture-mapping/shader.cpp:43: undefined reference to `_imp____glewDeleteShader&#39;
    ...texture-mapping/shader.cpp:46: undefined reference to `_imp____glewDeleteProgram&#39;
    CMakeFiles\texture_mapping.dir/objects.a(shader.cpp.obj): In function `ZN6Shader16CheckShaderErrorEjjbRKSs&#39;:
    ...texture-mapping/shader.cpp:79: undefined reference to `_imp____glewGetProgramiv&#39;
    ...texture-mapping/shader.cpp:81: undefined reference to `_imp____glewGetShaderiv&#39;
    ...texture-mapping/shader.cpp:86: undefined reference to `_imp____glewGetProgramInfoLog&#39;
    ...texture-mapping/shader.cpp:88: undefined reference to `_imp____glewGetShaderInfoLog&#39;
    CMakeFiles\texture_mapping.dir/objects.a(shader.cpp.obj): In function `ZN6Shader12CreateShaderERKSsj&#39;:
    ...texture-mapping/shader.cpp:96: undefined reference to `_imp____glewCreateShader&#39;
    ...texture-mapping/shader.cpp:109: undefined reference to `_imp____glewShaderSource&#39;
    ...texture-mapping/shader.cpp:110: undefined reference to `_imp____glewCompileShader&#39;
    CMakeFiles\texture_mapping.dir/objects.a(texture.cpp.obj): In function `ZN7Texture4BindEj&#39;:
    ...texture-mapping/texture.cpp:36: undefined reference to `_imp____glewActiveTexture&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x24): undefined reference to `SDL_SetMainReady&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x55): undefined reference to `SDL_malloc&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x84): undefined reference to `SDL_wcslen&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0xa5): undefined reference to `SDL_iconv_string&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0xcf): undefined reference to `SDL_free&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0xf4): undefined reference to `SDL_wcslen&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x10f): undefined reference to `SDL_iconv_string&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x143): undefined reference to `SDL_malloc&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x17f): undefined reference to `SDL_free&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x18b): undefined reference to `SDL_free&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x1d6): undefined reference to `SDL_isspace&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x295): undefined reference to `SDL_isspace&#39;
    ...texture-mapping/lib/SDL2main.lib(./Win32/Release/SDL_windows_main.obj):(.text+0x3a2): undefined reference to `SDL_ShowSimpleMessageBox&#39;

Basically, errors with every usage of SDL and glew, but not glm, which is strange.

What am I doing wrong with my `CMakeLists.txt`?

  [1]: http://i.stack.imgur.com/Bp3No.png

How to properly link libraries with cmake?

Can we restrict variadic template arguments to a certain type? I.e., achieve something like this (not real C++ of course):

    struct X {};

    auto foo(X... args)

Here my intention is to have a function which accepts a variable number of `X` parameters.

The closest we have is this:

    template &lt;class... Args&gt;
    auto foo(Args... args)

but this accepts any type of parameter.

Restrict variadic template arguments

C++17 added [`std::hardware_destructive_interference_size` and `std::hardware_constructive_interference_size`][1]. First, I thought it is just a portable way to get the size of a L1 cache line but that is an oversimplification.

Questions:

* How are these constants related to the L1 cache line size?
* Is there a good example that demonstrates their use cases?
* Both are defined `static constexpr`. Is that not a problem if you build a binary and execute it on other machines with different cache line sizes? How can it protect against false sharing in that scenario when you are not certain on which machine your code will be running?

  [1]: http://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size

Understanding std::hardware_destructive_interference_size and std::hardware_constructive_interference_size

Suppose we have a string

    std::string str; // some value is assigned

What is the difference between `str.empty()`  and `str[0] == &#39;\0&#39;`?

Difference between string.empty and string[0] == &#39;\0&#39;

&gt; This (made-up) question was initially formulated as a puzzle, concealing 
&gt; some of the details that might help seeing the problem faster. Scroll down
&gt; for the simpler [MCVE](https://stackoverflow.com/help/mcve) version.

---

# Original (a-la puzzle) version 

I have this piece of code that outputs `0`:

    #include &lt;iostream&gt;
    #include &lt;regex&gt;
    
    using namespace std;
    
    regex sig_regex(&quot;[0-9]+&quot;);
    bool oldmode = false;
    
    template&lt;class T&gt;
    struct B
    {
        T bitset;
    
        explicit B(T flags) : bitset(flags) {}
    
        bool foo(T n, string s)
        {
            return bitset &lt; 32                   // The mouth is not full of teeth
                   &amp;&amp; 63 &gt; (~n &amp; 255) == oldmode // Fooness holds
                   &amp;&amp; regex_match(s, sig_regex); // Signature matches
        }
    };
    
    template&lt;class T&gt;
    struct D : B&lt;T&gt;
    {
        D(T flags) : B&lt;T&gt;(flags) {}
    
    };
    
    int main()
    {
        D&lt;uint64_t&gt; d(128 | 16 | 1);
        cout &lt;&lt; d.foo(7, &quot;123&quot;) &lt;&lt; endl;
    }

However, when I move the function `foo()` from `B` to `D` it starts outputting `1` ([proof is on Coliru][1]).

Why does this happen?

---

# MCVE version

[**Live on Coliru**][2]

    #include &lt;iostream&gt;
    #include &lt;bitset&gt;
    
    using namespace std;
    
    template&lt;class T&gt;
    struct B
    {
        T bitset{0};
    
        bool foo(int x)
        {
            return bitset &lt; 32 &amp;&amp; 63 &gt; (x + 1) == x % 2;
        }
    };
    
    template&lt;class T&gt;
    struct D : B&lt;T&gt;
    {
        bool bar(int x) // This is identical to B&lt;T&gt;::foo()
        {
            return bitset &lt; 32 &amp;&amp; 63 &gt; (x + 1) == x % 2;
        }
    };
    
    int main()
    {
        D&lt;uint64_t&gt; d;
        cout &lt;&lt; d.foo(1) &lt;&lt; endl; // outputs 1
        cout &lt;&lt; d.bar(1) &lt;&lt; endl; // outputs 0; So how is bar() different from foo()?
    }


[1]: http://coliru.stacked-crooked.com/a/0b2464c54204660d
[2]: http://coliru.stacked-crooked.com/a/c8844fa1b85e1785

Moving a member function from base class to derived class breaks the program for no obvious reason

I&#39;m trying to write an if statement in [jinja template][1]:

    {% for key in data %}
        {% if key is &#39;priority&#39; %}
            &lt;p&gt;(&#39;Priority: &#39; + str(data[key])&lt;/p&gt;
        {% endif %}
    {% endfor %}

the statement I&#39;m trying to translate in Python is:

    if key == priority:
        print(print(&#39;Priority: &#39; + str(data[key]))
This is the error i&#39;m getting:

&gt; TemplateSyntaxError: expected token &#39;name&#39;, got &#39;string&#39;


  [1]: https://jinja.palletsprojects.com/en/2.11.x/

&#39;if&#39; statement in jinja2 template

The C++17 standard introduces &quot;template deduction guides&quot;. I gather they&#39;re something to do with the new template argument deduction for constructors introduced in this version of the standard, but I haven&#39;t yet seen a simple, FAQ-style explanation of what they are and what they&#39;re for.

  * What are template deduction guides in C++17?

  * Why (and when) do we need them?

  * How do I declare them?


What are template deduction guides and when should we use them?

Why on earth does the following piece of code work?

    struct A {
    	std::vector&lt;A&gt; subAs;
    };

A is an incomplete type, right? If there was a vector of A*s I would understand. But here I don&#39;t understand how it works. It seems to be a recursive definition.


Content Type	Original Author	Original Content on Stackoverflow
Question	Trevor Hickey	View Question on Stackoverflow
Solution 1 - C++	Barry	View Answer on Stackoverflow
Solution 2 - C++	skypjack	View Answer on Stackoverflow

Is there a difference between universal references and forwarding references?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

What does 'fileprivate' keyword means in Swift?

A Parser-blocking, cross-origin script is invoked via document.write - how to circumvent it?

Attributions