The language in the standard can be traced to [n3282][1], which is a resolution for defects [1207][2] and [1017][3].  In particular, the language appears in the proposed resolution for defect 1207, and thus should be considered in the context of the standard as it stood at the time that defect was addressed.  At that time there was some concern over the rewriting of id-expressions into member access expressions using `*this` (9.3.1p3), in particular in the context of trailing-return-type declarations (see issue [945][4]).

If we compare the proposed resolution to defect 1207 to the eventual language in n3282 and subsequently in the standard, there is one significant difference to 9.3.1p3:

### Defect 1207:

&gt; When an id-expression (5.1 [expr.prim]) that is not part of a class member access syntax (5.2.5 [expr.ref]) and not used to form a pointer to member (5.3.1 [expr.unary.op]) is used in **the declaration of a member function of class `X`**, if name lookup (3.4 [basic.lookup]) resolves the name...

### n3282 and C++11:

&gt; When an id-expression (5.1 [expr.prim]) that is not part of a class member access syntax (5.2.5 [expr.ref]) and not used to form a pointer to member (5.3.1 [expr.unary.op]) is used in **a member of class `X` in a context where `this` can be used (5.1.1 [expr.prim.general])**, if name lookup (3.4 [basic.lookup]) resolves the name [...]

It is apparent that the proposed resolution to defect 1207 carried the belief that id-expressions (to a static member) within a static member functions would need to be transformed to `*this` member access expressions and thus would need access to the type and value category of `this`.  By the time n3282 was written this had been resolved in favour of the qualified-id transformation (also 9.3.1p3) which does not require `this`, but the language in 5.1.1p3 remained vestigially.

I would recommend raising this issue on the C++ standards discussion newsgroup; it may be possible to get the vestigial language removed editorially.

  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3282.pdf
  [2]: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1207
  [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1017
  [4]: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#945

How can I reference (insert a relative link to) an issue in my github Readme.md?

I found the following document [GitHub Flavored Markdown][1] where it is described how to reference to an issue in a commit, but not in the readme.

E.g. if the Issue is: https://github.com/user/project/issues/5 how can I set a link to it in my readme without using absolute links?


  [1]: https://help.github.com/articles/github-flavored-markdown

github Readme - reference issue

I have followed this link and successfully made singleton class in Android.
http://www.devahead.com/blog/2011/06/extending-the-android-application-class-and-dealing-with-singleton/

Problem is that i want a single object. like i have Activity A and Activity B. In Activity A I access the object from Singleton `class`. I use the object and made some changes to it.

When I move to Activity B and access the object from Singleton Class it gave me the initialized object and does not keep the changes which i have made in Activity A.
Is there any other way to save the changing?
Please help me Experts.
This is `MainActivity`


    public class MainActivity extends Activity {
    	protected MyApplication app;		
    	private OnClickListener btn2=new OnClickListener() {	
    		@Override
    		public void onClick(View arg0) {
    			Intent intent=new Intent(MainActivity.this,NextActivity.class);
    			startActivity(intent);				
    		}
    	};
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_main);
    
    		//Get the application instance
    	    app = (MyApplication)getApplication();
    	     
    	    // Call a custom application method
    	    app.customAppMethod();
    	     
    	    // Call a custom method in MySingleton
    	    Singleton.getInstance().customSingletonMethod();
    	 
    	    Singleton.getInstance();
    		// Read the value of a variable in MySingleton
    	    String singletonVar = Singleton.customVar;
    	    
    	    Log.d(&quot;Test&quot;,singletonVar);
    	    singletonVar=&quot;World&quot;;
    	    Log.d(&quot;Test&quot;,singletonVar);
    	    
    		Button btn=(Button)findViewById(R.id.button1);
    		btn.setOnClickListener(btn2);
    	}
    
    }

This is `NextActivity`

    
    public class NextActivity extends Activity {
        	
        	@Override
        	protected void onCreate(Bundle savedInstanceState) {
        		super.onCreate(savedInstanceState);
        		setContentView(R.layout.activity_next);
        		
        	    String singletonVar = Singleton.customVar;
        	    
        	    Log.d(&quot;Test&quot;,singletonVar);
        	}
      }
    
`Singleton` Class
    
    public class Singleton
    {
        private static Singleton instance;
       
        public static String customVar=&quot;Hello&quot;;
       
        public static void initInstance()
        {
        if (instance == null)
        {
          // Create the instance
          instance = new Singleton();
        }
        }
     
        public static Singleton getInstance()
        {
         // Return the instance
         return instance;
         }
       
         private Singleton()
         {
         // Constructor hidden because this is a singleton
         }
       
         public void customSingletonMethod()
         {
         // Custom method
         }
     }

and `MyApplication`

    public class MyApplication extends Application
        {
        @Override
        public void onCreate()
        {
        super.onCreate();
        
         // Initialize the singletons so their instances
         // are bound to the application process.
         initSingletons();
         }
    
         protected void initSingletons()
         {
         // Initialize the instance of MySingleton
         Singleton.initInstance();
         }
      
         public void customAppMethod()
         {
         // Custom application method
        }
    }



When i run this code, i get Hello which i have initialized in `Singleton` then World which i gave it in `MainActivity` and again shows Hello in `NextActivity` in logcat.
I want it to show world again in `NextActivity`.
Please help me to correct this.


Singleton in Android

In C++ 5.1.1/3 [expr.prim.general] it says:

&gt; The type and value category [of `this`] are defined within a static member function.

What does this mean?  How is it relevant?

Note that:

&gt; `this` shall not appear in the declaration of a static member function


Type of `this` in static member function?

In C++ 5.1.1/3 [expr.prim.general] it says:
> The type and value category [of <code>this</code>] are defined within a static member function.
What does this mean? How is it relevant?
Note that:
> <code>this</code> shall not appear in the declaration of a static member function

I need to store multiple types of a template class in a single vector.

Eg, for:

    template &lt;typename T&gt;
    class templateClass{
         bool someFunction();
    };

I need one vector that will store all of:

    templateClass&lt;int&gt; t1;
    templateClass&lt;char&gt; t2;
    templateClass&lt;std::string&gt; t3;
    etc

As far as I know this is not possible, if it is could someone say how?


If it isn&#39;t  possible could someone explain how to make the following work?

As a work around I tried to use a base, non template class and inherit the template class from it.

     class templateInterface{
         virtual bool someFunction() = 0;
     };

     template &lt;typename T&gt;
     class templateClass : public templateInterface{
         bool someFunction();
     };
I then created a vector to store the base &quot;templateInterface&quot; class:
    
    std::vector&lt;templateInterface&gt; v;
    templateClass&lt;int&gt; t;
    v.push_back(t);

This produced the following error:

    error: cannot allocate an object of abstract type &#39;templateInterface&#39;
    note: because the following virtual functions are pure within &#39;templateInterface&#39;
    note: virtual bool templateInterface::someFunction()

To fix this error I made the function in templateInterface not a pure virtual by providing a function body, this compiled but when calling the function the overide is not used, but instead the body in the virtual function.

Eg:

     class templateInterface{
         virtual bool someFunction() {return true;}
     };

     template &lt;typename T&gt;
     class templateClass : public templateInterface{
         bool someFunction() {return false;}
     };

     std::vector&lt;templateInterface&gt; v;
     templateClass&lt;int&gt; i;
     v.push_back(i);
     v[0].someFunction(); //This returns true, and does not use the code in the &#39;templateClass&#39; function body

Is there any way to fix this so that the overridden function is used, or is there another workaround to store multiple template types in a single vector?


     



C++ One std::vector containing template class of multiple types

The C++11 standard specifies a number of different engines for random number generation: `linear_congruential_engine`, `mersenne_twister_engine`, `subtract_with_carry_engine` and so on. Obviously, this is a large change from the old usage of `std::rand`. 

Obviously, one of the major benefits of (at least some) of these engines is the massively increased period length (it&#39;s built into the name for `std::mt19937`). 

However, the differences between the engines is less clear. What are the strengths and weaknesses of the different engines? When should one be used over the other? Is there a sensible default that should generally be preferred?

Random Engine Differences

I would like to record the users webcam and audio and save it to a file on the server. These files would then be able to be served up to other users.

I have no problems with playback, however I&#39;m having problems getting the content to record.

My understanding is that the getUserMedia `.record()` function has not yet been written - only a proposal has been made for it so far.

I would like to create a peer connection on my server using the PeerConnectionAPI. I understand this is a bit hacky, but I&#39;m thinking it should be possible to create a peer on the server and record what the client-peer sends.

If this is possible, I should then be able to save this data to flv or any other video format.

My preference is actually to record the webcam + audio client-side, to allow the client to re-record videos if they didn&#39;t like their first attempt before uploading. This would also allow for interruptions in network connections. I&#39;ve seen some code which allows recording of individual &#39;images&#39; from the webcam by sending the data to the canvas - that&#39;s cool, but I need the audio too.

Here&#39;s the client side code I have so far:
  

      &lt;video autoplay&gt;&lt;/video&gt;
    
    &lt;script language=&quot;javascript&quot; type=&quot;text/javascript&quot;&gt;
    function onVideoFail(e) {
        console.log(&#39;webcam fail!&#39;, e);
      };
      
    function hasGetUserMedia() {
      // Note: Opera is unprefixed.
      return !!(navigator.getUserMedia || navigator.webkitGetUserMedia ||
                navigator.mozGetUserMedia || navigator.msGetUserMedia);
    }
    
    if (hasGetUserMedia()) {
      // Good to go!
    } else {
      alert(&#39;getUserMedia() is not supported in your browser&#39;);
    }
    
    window.URL = window.URL || window.webkitURL;
    navigator.getUserMedia  = navigator.getUserMedia || navigator.webkitGetUserMedia ||
                              navigator.mozGetUserMedia || navigator.msGetUserMedia;
    
    var video = document.querySelector(&#39;video&#39;);
    var streamRecorder;
    var webcamstream;
    
    if (navigator.getUserMedia) {
      navigator.getUserMedia({audio: true, video: true}, function(stream) {
        video.src = window.URL.createObjectURL(stream);
    	webcamstream = stream;
    //	streamrecorder = webcamstream.record();
      }, onVideoFail);
    } else {
    	alert (&#39;failed&#39;);
    }
    
    function startRecording() {
    	streamRecorder = webcamstream.record();
    	setTimeout(stopRecording, 10000);
    }
    function stopRecording() {
    	streamRecorder.getRecordedData(postVideoToServer);
    }
    function postVideoToServer(videoblob) {
    /*	var x = new XMLHttpRequest();
    	x.open(&#39;POST&#39;, &#39;uploadMessage&#39;);
    	x.send(videoblob);
    */
    	var data = {};
    	data.video = videoblob;
    	data.metadata = &#39;test metadata&#39;;
    	data.action = &quot;upload_video&quot;;
    	jQuery.post(&quot;http://www.foundthru.co.uk/uploadvideo.php&quot;, data, onUploadSuccess);
    }
    function onUploadSuccess() {
    	alert (&#39;video uploaded&#39;);
    }
    
    &lt;/script&gt;
    
    &lt;div id=&quot;webcamcontrols&quot;&gt;
    	&lt;a class=&quot;recordbutton&quot; href=&quot;javascript:startRecording();&quot;&gt;RECORD&lt;/a&gt;
    &lt;/div&gt;



How to record webcam and audio using webRTC and a server-based Peer connection

Where exactly is the &#39;this&#39; pointer stored in memory? Is it allocated on the stack, in the heap, or in the data segment?

    #include &lt;iostream&gt;
    using namespace std;

    class ClassA
    {
        int a, b;

        public:
            void add()
            {
                a = 10;
                b = 20;
                cout &lt;&lt; a &lt;&lt; b &lt;&lt; endl;
            }
    };

    int main()
    {
        ClassA obj;
        obj.add();
        return 0;
    }

In the above code I am calling the member function `add()` and the receiver object is passed implicitly as the &#39;this&#39; pointer. Where is `this` stored in memory?


Where is the &#39;this&#39; pointer stored in computer memory?

In C++11, [`std::to_string`][1] defaults to 6 decimal places when given an input value of type `float` or `double`. What is the recommended, or most elegant, method for changing this precision?


  [1]: http://en.cppreference.com/w/cpp/string/basic_string/to_string

Set precision of std::to_string when converting floating point values

`std::unique_ptr` has support for arrays, for instance:

    std::unique_ptr&lt;int[]&gt; p(new int[10]);

but is it needed? probably it is more convenient to use `std::vector` or `std::array`.

Do you find any use for that construct?

Is there any use for unique_ptr with array?

I saw code somewhere in which someone decided to copy an object and subsequently move it to a data member of a class. This left me in confusion in that I thought the whole point of moving was to avoid copying. Here is the example:

    struct S
    {
        S(std::string str) : data(std::move(str))
        {}
    };

Here are my questions:

 - Why aren&#39;t we taking an rvalue-reference to `str`?
 - Won&#39;t a copy be expensive, especially given something like `std::string`?
 - What would be the reason for the author to decide to make a copy then a move?
 - When should I do this myself?

Why do we copy then move?

Is it possible to store a parameter pack somehow for a later use?

    template &lt;typename... T&gt;
    class Action {
    private:        
        std::function&lt;void(T...)&gt; f;
        T... args;  // &lt;--- something like this
    public:
        Action(std::function&lt;void(T...)&gt; f, T... args) : f(f), args(args) {}
        void act(){
            f(args);  // &lt;--- such that this will be possible
        }
    }

Then later on:
    
    void main(){
        Action&lt;int,int&gt; add([](int x, int y){std::cout &lt;&lt; (x+y);}, 3, 4);

        //...

        add.act();
    }

How to store variadic template arguments?

First, to clarify, I am **not** talking about dereferencing invalid pointers!

Consider the following two examples.

**Example 1**

    typedef struct { int *p; } T;

    T a = { malloc(sizeof(int) };
    free(a.p);  // a.p is now indeterminate?
    T b = a;    // Access through a non-character type?

**Example 2**

    void foo(int *p) {}

    int *p = malloc(sizeof(int));
    free(p);   // p is now indeterminate?
    foo(p);    // Access through a non-character type?

**Question**

Do either of the above examples invoke undefined behaviour?

**Context**

This question is posed in response to [this discussion](https://stackoverflow.com/questions/17019778/what-will-happen-if-a-stdvector-element-commits-suicide-using-delete-this/17019929#comment24597487_17019929).  The suggestion was that, for example, pointer arguments may be passed to a function via x86 segment registers, which could cause a hardware exception.

From the C99 standard, we learn the following (emphasis mine):

&gt; **[3.17]** *indeterminate value* - either an unspecified value or a **trap representation**

and then:

&gt; **[6.2.4 p2]** The value of a pointer becomes **indeterminate** when
the object it points to reaches the end of its lifetime.

and then:

&gt; **[6.2.6.1 p5]** Certain object representations need not represent a value of the object type. If the stored value of an object has such a representation and is read by an lvalue expression that does not have character type, **the behavior is undefined**. If such a representation is produced by a side effect that modifies all or any part of the object by an lvalue expression that does not have character type, the behavior is undefined.  Such a representation is called a **trap representation**.

Taking all of this together, what restrictions do we have on accessing pointers to &quot;dead&quot; objects?

**Addendum**

Whilst I&#39;ve quoted the C99 standard above, I&#39;d be interested to know if the behaviour differs in any of the C++ standards.


When is it valid to access a pointer to a &quot;dead&quot; object?

The following code is quite trivial and I expected that it should compile fine.

    struct A
    {
        struct B
        {
            int i = 0;
        };
    
        B b;
    
        A(const B&amp; _b = B())
            : b(_b)
        {}
    };

I&#39;ve tested this code with g++ version 4.7.2, 4.8.1, clang++ 3.2 and 3.3. Apart from fact that g++ 4.7.2 segfaults on this code (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57770), the other tested compilers give error messages that don&#39;t explain much.

g++ 4.8.1:

    test.cpp: In constructor ‘constexpr A::B::B()’:
    test.cpp:3:12: error: constructor required before non-static data member for ‘A::B::i’ has been parsed
         struct B
                ^
    test.cpp: At global scope:
    test.cpp:11:23: note: synthesized method ‘constexpr A::B::B()’ first required here 
         A(const B&amp; _b = B())
                           ^

 clang++ 3.2 and 3.3:

    test.cpp:11:21: error: defaulted default constructor of &#39;B&#39; cannot be used by non-static data member initializer which appears before end of class definition
        A(const B&amp; _b = B())
                        ^

Making this code compilable is possible and seems like it should make no difference. There are two options:

    struct B
    {
        int i = 0;
        B(){} // using B()=default; works only for clang++
    };

or

    struct B
    {
        int i;
        B() : i(0) {} // classic c++98 initialization
    };

Is this code really incorrect or are the compilers wrong?

Error when using in-class initialization of non-static data member and nested class constructor

What is the difference between the following two lines?

    map&lt;int, float&gt; map_data;
    map&lt;const int, float&gt; map_data;


What is difference between const and non const key?

I know that generally the standard places few requirements on the values which have been moved from:

N3485 17.6.5.15 [lib.types.movedfrom]/1:

 &gt;Objects of types defined in the C++ standard library may be moved from (12.8). Move operations may
be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

I can&#39;t find anything about `vector` that explicitly excludes it from this paragraph. However, I can&#39;t come up with a sane implementation that would result in the vector being not empty.

Is there some standardese that entails this that I&#39;m missing or is this similar to [treating `basic_string` as a contiguous buffer in C++03](https://stackoverflow.com/questions/2256160/is-it-reasonable-to-use-stdbasic-stringt-as-a-contiguous-buffer-when-targeti)?

Is a moved-from vector always empty?

Consider this C++ code:

    enum class Color : char { red = 0x1, yellow = 0x2 }
    // ...
    char *data = ReadFile();
    Color color = static_cast&lt;Color&gt;(data[0]);

Suppose that data[0] is actually 100. What is color set to according to the standard?
In particular, if I later do

    switch (color) {
        // ... red and yellow cases omitted
        default:
            // handle error
            break;
    }

does the standard guarantee that default will be hit? If not, what is the proper, most efficient, most elegant way to check for an error here? Does the standard make any guarantees as about this but with plain enum?

Content Type	Original Author	Original Content on Stackoverflow
Question	Andrew Tomazos	View Question on Stackoverflow
Solution 1 - C++	ecatmur	View Answer on Stackoverflow

Type of `this` in static member function?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Defect 1207:

n3282 and C++11:

Singleton in Android

github Readme - reference issue

Attributions