`std::this_thread::yield` tells the implementation to reschedule the execution of threads, that should be used in a case where you are in a busy waiting state, like in a thread pool:

    ...
    while(true) {
      if(pool.try_get_work()) {
        // do work
      }
      else {
        std::this_thread::yield(); // other threads can push work to the queue now
      }
    }


`std::this_thread::sleep_for` can be used if you really want to  wait for a specific amount of time. This can be used for task, where timing really matters, e.g.: if you really only want to wait for 2 seconds. (Note that the implementation might wait longer than the given time duration)


&gt; std::this_thread::sleep_for()

will make your thread sleep for a given time (the thread is stopped for a given time).
([http://en.cppreference.com/w/cpp/thread/sleep_for][1])

&gt; std::this_thread::yield()

will stop the execution of the current thread and give priority to other process/threads (if there are other process/threads waiting in the queue).
The execution of the thread is not stopped. (it just release the CPU).
([http://en.cppreference.com/w/cpp/thread/yield][2])


  [1]: http://en.cppreference.com/w/cpp/thread/sleep_for
  [2]: http://en.cppreference.com/w/cpp/thread/yield

What is the *nix command to view a user&#39;s default login shell?

I can change the default login shell with `chsh`, but I don&#39;t know how to get what is the user&#39;s default shell.

Pseudocode

    $ get-shell
    /usr/bin/zsh


What is the *nix command to view a user&#39;s default login shell

how do I add `&#39;d&#39;` to the index below without having to reset it first?

    from pandas import DataFrame
    df = DataFrame( {&#39;a&#39;: range(6), &#39;b&#39;: range(6), &#39;c&#39;: range(6)} )
    df.set_index([&#39;a&#39;,&#39;b&#39;], inplace=True)
    df[&#39;d&#39;] = range(6)
    
    # how do I set index to &#39;a b d&#39; without having to reset it first?
    df.reset_index([&#39;a&#39;,&#39;b&#39;,&#39;d&#39;], inplace=True)
    df.set_index([&#39;a&#39;,&#39;b&#39;,&#39;d&#39;], inplace=True)
    
    df


Pandas DataFrame Add column to index without resetting

What is the difference between C++11 `std::this_thread::yield()` and `std::this_thread::sleep_for()`? How to decide when to use which one?

std::this_thread::yield() vs std::this_thread::sleep_for()

<p>What is the difference between C++11 <code>std::this_thread::yield()</code> and <code>std::this_thread::sleep_for()</code>? How to decide when to use which one?</p>


I have the following class:

    class risc { // singleton
        protected:
            static unsigned long registers[8];
    
        public:
            unsigned long operator [](int i)
            {
                return registers[i];
            }
    };

as you can see I&#39;ve implemented the square brackets operator for &quot;getting&quot;.  
Now I would like to implement it for setting, i.e.: `risc[1] = 2`.

How can it be done?

Overload bracket operators [] to get and set

Let&#39;s assume this scenario in Visual C++ 2010:

	#include &lt;iostream&gt;
	#include &lt;conio.h&gt;

	using namespace std;

	class Base
	{
	public:
		int b;
		void Display()
		{
			cout&lt;&lt;&quot;Base: Non-virtual display.&quot;&lt;&lt;endl;
		};
		virtual void vDisplay()
		{
			cout&lt;&lt;&quot;Base: Virtual display.&quot;&lt;&lt;endl;
		};
	};

	class Derived : public Base
	{
	public:
		int d;
		void Display()
		{
			cout&lt;&lt;&quot;Derived: Non-virtual display.&quot;&lt;&lt;endl;
		};
		virtual void vDisplay()
		{
			cout&lt;&lt;&quot;Derived: Virtual display.&quot;&lt;&lt;endl;
		};
	};

	int main()
	{
		Base ba;
		Derived de;

		ba.Display();
		ba.vDisplay();
		de.Display();
		de.vDisplay();

		_getch();
		return 0;
	};

Theoretically, the output of this little application should be:

 - Base: Non-virtual display.
 - Base: Virtual display.
 - ***Base: Non-virtual display.***
 - Derived: Virtual display.

because the Display method of the Base class is not a virtual method so the Derived class should not be able to override it. Right?

The problem is that when I run the application, it prints this:

 - Base: Non-virtual display.
 - Base: Virtual display.
 - ***Derived: Non-virtual display.***
 - Derived: Virtual display.

So either I didn&#39;t understand the concept of virtual methods or something strange happens in Visual C++.

Could someone help me with an explanation?



Overriding non-virtual methods

I&#39;m trying to compile a C++ software package that was written in 2007 and I&#39;m getting this error:

`error: ‘uint32_t’ does not name a type`

This is happening in 64-bit Ubuntu using g++ 4.5.2. It compiles fine on 64-bit CentOS using g++ 4.1.2.

Is there an `#include` or a compiler flag that I&#39;m missing? Or, should I use `typedef` to assign `uint32_t` to a `size_t` or maybe an `unsigned int`?

&#39;uint32_t&#39; does not name a type

In case of `ifstream` in C++, under what conditions are `failbit` and `badbit` flags set ?

C++ ifstream failbit and badbit

I have seen a lot of people in the C++ community(particularly ##c++ on freenode) resent the use of `wstrings` and `wchar_t`, and their use in the windows api. What is exactly &quot;wrong&quot; with `wchar_t` and `wstring`, and if I want to support internationalization, what are some alternatives to wide characters?

What&#39;s &quot;wrong&quot; with C++ wchar_t and wstrings? What are some alternatives to wide characters?

In an android service I have created thread(s) for doing some background task. 

I have a situation where a thread needs to post certain task on main thread&#39;s message queue, for example a `Runnable`.

Is there a way to get `Handler` of the main thread and post `Message`/`Runnable` to it from my other thread?

Running code in main thread from another thread

Please clarify my queries regarding Singleton and Multithreading:

 - What is the best way to implement Singleton in Java, in a multithreaded
   environment?
 - What happens when multiple threads try to access `getInstance()`
   method at the same time?
 - Can we make singleton&#39;s `getInstance()` `synchronized`?
 - Is synchronization really needed, when using Singleton classes?

Java Singleton and Synchronization

I have a single big text file in which I want to process each line ( do some operations ) and store them in a database. Since a single simple program is taking too long, I want it to be done via multiple processes or threads. 
Each thread/process should read the DIFFERENT data(different lines) from that single file and do some operations on their piece of data(lines) and put them in the database so that in the end, I have whole of the data processed and my database is dumped with the data I need.

But I am not able to figure it out that how to approach this. 


Processing single file from multiple processes

I often find these terms being used in context of concurrent programming . Are they the same thing or different ?

Are &quot;data races&quot; and &quot;race condition&quot; actually the same thing in context of concurrent programming

I have this code : 


    void Main()
    {
    	System.Timers.Timer t = new System.Timers.Timer (1000);
    	t.Enabled=true;
    	t.Elapsed+= (sender, args) =&gt;c();
    	Console.ReadLine();
    	
    }

    int h=0;
    public void c()
    {
        h++;
        new Thread(() =&gt; doWork(h)).Start();
    }

    public void doWork(int h)
    {
        Thread.Sleep(3000);
        h.Dump();
    }

I wanted to see what happens if the interval is 1000 ms and the job process is 3000 ms.

However I saw a strange behavior - 
the 3000 ms delay occurs *only at the start* !

How can I make each `doWork` sleep 3000 ms?


As you can see here, at the beginning there is a 3 second delay, and then it iterates 1 second each.

![enter image description here][1]


  [1]: http://i.stack.imgur.com/IdBVV.gif

C# Thread won&#39;t sleep?

C++11 supports a new function syntax:

    auto func_name(int x, int y) -&gt; int;

Currently this function would be declared as:

    int func_name(int x, int y);

The new style does not seem to be widely adopted yet (say in the gcc stl)

However, should this new style be preferred everywhere in new C++11-programs, or will it only be used when needed?

Personally, I prefer the old style when possible, but a code-base with mixed styles looks pretty ugly.

Should the trailing return type syntax style become the default for new C++11 programs?

I am having my first attempt at using C++11 `unique_ptr`; I am replacing a polymorphic raw pointer inside a project of mine, which is owned by one class, but passed around quite frequently.

I used to have functions like:

    bool func(BaseClass* ptr, int other_arg) {
      bool val;
      // plain ordinary function that does something...
      return val;
    }

But I soon realized that I wouldn&#39;t be able to switch to:

    bool func(std::unique_ptr&lt;BaseClass&gt; ptr, int other_arg);

Because the caller would have to handle the pointer ownership to the function, what I don&#39;t want to. So, what is the best solution to my problem?

I though of passing the pointer as reference, like this:

    bool func(const std::unique_ptr&lt;BaseClass&gt;&amp; ptr, int other_arg);

But I feel very uncomfortable in doing so, firstly because it seems non instinctive to pass something already typed as `_ptr` as reference, what would be a reference of a reference. Secondly because the function signature gets even bigger. Thirdly, because in the generated code, it would be necessary two consecutive pointer indirections to reach my variable.

How to pass std::unique_ptr around?

Does C++11 allow declaring non-static data members as &#39;auto&#39; if they are initialized in the declaration? For example:

    struct S
    {
        auto x = 5;  // in place of &#39;int x = 5;&#39;, which is definitely allowed
    };

GCC 4.7 rejects the above code, while it accepts `int x = 5;`.

Assuming this is not a compiler bug but rather the standard really doesn&#39;t allow it, why not? It would be just as useful as declaring local variables `auto`.

C++11 - declaring non-static data members as &#39;auto&#39;

What&#39;s the difference between sizeof and alignof?

    #include &lt;iostream&gt;

    #define SIZEOF_ALIGNOF(T) std::cout&lt;&lt; sizeof(T) &lt;&lt; &#39;/&#39; &lt;&lt; alignof(T) &lt;&lt; std::endl
    
    int main(int, char**)
    {
            SIZEOF_ALIGNOF(unsigned char);
            SIZEOF_ALIGNOF(char);
            SIZEOF_ALIGNOF(unsigned short int);
            SIZEOF_ALIGNOF(short int);
            SIZEOF_ALIGNOF(unsigned int);
            SIZEOF_ALIGNOF(int);
            SIZEOF_ALIGNOF(float);
            SIZEOF_ALIGNOF(unsigned long int);
            SIZEOF_ALIGNOF(long int);
            SIZEOF_ALIGNOF(unsigned long long int);
            SIZEOF_ALIGNOF(long long int);
            SIZEOF_ALIGNOF(double);
    }

will output

1/1
1/1
2/2
2/2
4/4
4/4
4/4
4/4
4/4
8/8
8/8
8/8

I think I don&#39;t get what the alignment is...?

What&#39;s the difference between sizeof and alignof?

Code:

    std::vector&lt;int&gt; x{1,2,3,4};
    std::array&lt;int, 4&gt; y{{1,2,3,4}};

Why do I need double curly braces for std::array?


Content Type	Original Author	Original Content on Stackoverflow
Question	polapts	View Question on Stackoverflow
Solution 1 - C++	Stephan Dollberg	View Answer on Stackoverflow
Solution 2 - C++	neam	View Answer on Stackoverflow

std::this_thread::yield() vs std::this_thread::sleep_for()

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Pandas DataFrame Add column to index without resetting

What is the *nix command to view a user's default login shell

Attributions