The literal prefixes are a part of the core language, much like the suffixes:

    &#39;a&#39;    // type: char
    L&#39;a&#39;   // type: wchar_t

    &quot;a&quot;    // type: char[2]
    L&quot;a&quot;   // type: wchar_t[2]
    U&quot;a&quot;   // type: char32_t[2]

    1      // type: int
    1U     // type: unsigned int

    0.5    // type: double
    0.5f   // type: float
    0.5L   // type: long double


Note that `wchar_t` has *nothing* to do with Unicode. Here is an [extended rant of mine](https://stackoverflow.com/questions/6300804/wchars-encodings-standards-and-portability) on the topic.

It&#39;s called an **encoding prefix**:

###2.14.5 String literals [lex.string]

&gt;`string-literal`:&lt;br/&gt;
   | `encoding-prefix`&lt;sub&gt;`opt`&lt;/sub&gt;&quot; `s-char-sequenceopt`&quot;&lt;br/&gt;
   | `encoding-prefix`&lt;sub&gt;`opt`&lt;/sub&gt;R `raw-string`&lt;br/&gt;
  `encoding-prefix`:&lt;br/&gt;
     |  `u8`&lt;br/&gt;
     |  `u`&lt;br/&gt;
     |  `U`&lt;br/&gt;
     |  `L`&lt;br/&gt;

and marks a wide string literal:

&gt; 11) A string literal that begins with `L`, such as `L&quot;asdf&quot;`, is a wide
&gt; string literal. A wide string literal has type “array of `n` `const
&gt; wchar_t`”, where n is the size of the string as defined below; it has
&gt; static storage duration and is initialized with the given characters.

The meaning of L here is wide character: `wchar_t`. String with L is coded in 16bit rather than 8bit, take an example:

    &quot;A&quot;    = 41
    L&quot;A&quot;   = 00 41

I&#39;m developing pages, now in my css style I have this line of code

    .flex-control-thumbs li {
        width: 25%;
        float: left;
        margin: 0;
    }

for my pages. Now, some of my pages don&#39;t need this line
  
    width: 25%;
    float: left;

It is possible that I can overwrite it in internal css of the page, which will cause the original behaviour to be ignored?



how to overwrite css style

I&#39;d like the question to be answered in general, but to illustrate it, here&#39;s a use case:

I&#39;m using Vagrant for a simple LMAP project. I use standalone Puppet for provisioning. Now, there might be some developers who sit behind a proxy and they would need some additional configuration to be made to the VM. I have things working on the Puppet side: I can pass the proxy IP (if any) as a fact to puppet in the `Vagrantfile` and Puppet reacts accordingly if it&#39;s set.

The only issue I have is: how can developers specify/override this setting for their development environment without having to change the `Vagrantfile` (which is under version control and must remain dev-environment-neutral)?

If would be awesome if people could override some Vagrant settings in a file called e.g. `Vagrantfile.local`, which I would exclude via `.gitignore`.

Since a Vagrantfile is just Ruby, I tried the following:

    # Also load per-dev custom vagrant config
    custom_vagrantfile = &#39;Vagrantfile.local&#39;
    load custom_vagrantfile if File.exist?(custom_vagrantfile)

The file inclusion basically works, but it looks like in the included file, I&#39;m not in the same Vagrant context anymore...

    Vagrant::Config.run do |config|
      config.vm.provision :puppet do |puppet|
        puppet.facter = { &quot;proxy&quot; =&gt; &quot;proxy.host:80&quot; }
      end
    end

... also &quot;resets&quot; all other puppet config values I made in the main `Vagrantfile`, which makes me think I&#39;m heading in the wrong direction here. I should note that I&#39;m a total noob at Ruby ;)

Can anyone give me a hint or even a working solution for how per-dev customization could be done here in general?

Override Vagrant configuration settings locally (per-dev)

I understand what it does: specifies a string literal as a `const wchar_t *` (wide character string) instead of `const char *` (plain old characters), but how is it actually defined?

Is it a macro of some sort? Is it an operator for GCC compilers? What *is* it?

What exactly is the L prefix in C++?

I understand what it does: specifies a string literal as a <code>const wchar_t *</code> (wide character string) instead of <code>const char *</code> (plain old characters), but how is it actually defined?
Is it a macro of some sort? Is it an operator for GCC compilers? What is it?

I am a bit confused about the role of `std::unique_lock` when working with `std::condition_variable`. As far as I understood the [documentation][1], `std::unique_lock` is basically a bloated lock guard, with the possibility to swap the state between two locks.

I&#39;ve so far used `pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)` for this purpose (I guess that&#39;s what the STL uses on posix). It takes a mutex, not a lock.

What&#39;s the difference here? Is the fact that `std::condition_variable` deals with `std::unique_lock` an optimization? If so, how exactly is it faster?


  [1]: http://en.cppreference.com/w/cpp/thread/unique_lock

C++11: why does std::condition_variable use std::unique_lock?

From the [GCC 4.8 draft changelog](http://gcc.gnu.org/gcc-4.8/changes.html#cxx):

&gt; G++ now implements the [C++11](http://gcc.gnu.org/gcc-4.8/cxx0x_status.html) `thread_local` keyword; this differs from
&gt; the GNU `__thread` keyword primarily in that it allows dynamic
&gt; initialization and destruction semantics. Unfortunately, this support
&gt; requires a run-time penalty for references to non-function-local
&gt; `thread_local` variables even if they don&#39;t need dynamic initialization,
&gt; so users may want to continue to use `__thread` for TLS variables with
&gt; static initialization semantics.

What is precisely the nature and origin of this run-time penalty?

Obviously to support non-function-local `thread_local` variables there needs to be a thread initialization phase before the entry to every thread main (just as there is a static initialization phase for global variables), but are they referring to some run-time penalty beyond that?

Roughly speaking what is the architecture of gcc&#39;s new implementation of thread_local?

What is the performance penalty of C++11 thread_local variables in GCC 4.8?

I know in C++11 they added the feature to initialize a variable to zero as such 

    double number = {}; // number = 0
    int data{};  // data = 0
    
Is there a similar way to initialize a `std::vector` of a fixed length to all zero&#39;s?

initialize a vector to zeros C++/C++11

How do I show a message box with Yes/No buttons in Qt, and how do I check which of them was pressed?

I.e. a message box that looks like this:

![enter image description here][1]

  [1]: http://i.stack.imgur.com/h92PA.png

Yes/No message box using QMessageBox

I&#39;m using CMake with my project and set up a cdash server for continuous/nightly building. Everything works well and by setting up a crontab, we have hourly/nightly build/test results uploaded to our cdash server automatically.

My next step is to add test coverage report to the build. I find the document here http://www.cmake.org/Wiki/CTest:Coverage but frankly it&#39;s a bit far from a practical guide.

Currently I&#39;ve added the required flag (instead of `-fprofile-arcs -ftest-coverage`, I find `--coverage` better), the compilation process generates .gcno files. But then I&#39;m stuck. The command 

    make NightlyCoverage

doesn&#39;t seem to do anything. Could anybody tell me what is the next to do? The result that I want, is by doing `make NightlyCoverage`, coverage reports are generated and uploaded to cdash server.



Detailed guide on using gcov with CMake/CDash?

I wrote this small piece of code in C to test `memcmp()` `strncmp()` `strcmp()` functions in C.

Here is the code that I wrote:

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    #include &lt;string.h&gt;
    
    int main() {
            char *word1=&quot;apple&quot;,*word2=&quot;atoms&quot;;
    
            if (strncmp(word1,word2,5)==0)
                    printf(&quot;strncmp result.\n&quot;);
            if (memcmp(word1,word2,5)==0)
                    printf(&quot;memcmp result.\n&quot;);
            if (strcmp(word1,word2)==0)
                    printf(&quot;strcmp result.\n&quot;);
    }

Can somebody explain me the differences because I am confused with these three functions?

My main problem is that I have a file in which I tokenize its line of it,the problem is that when I tokenize the word &quot;atoms&quot; in the file I have to stop the process of tokenizing.

I first tried `strcmp()` but unfortunately when it reached to the point where the word &quot;atoms&quot; were placed in the file it didn&#39;t stop and it continued,but when I used either the `memcmp()` or the `strncmp()` it stopped and I was happy.

But then I thought,what if there will be a case in which there is one string in which the first 5 letters are a,t,o,m,s and these are being followed by other letters.

Unfortunately,my thoughts were right as I tested it using the above code by initializing `word1` to &quot;atomsaaaaa&quot; and `word2` to atoms and `memcmp()` and `strncmp()` in the if statements returned 0.On the other hand `strcmp()` it didn&#39;t. It seems that I must use `strcmp()`.



What is the difference between memcmp, strcmp and strncmp in C?

I&#39;m on Ubuntu, and I&#39;d like to find all files in the current directory and subdirectories whose name contains the string &quot;John&quot;. I know that `grep` can match the content of the files, but I have no idea how to use it with file names.

Linux find file names with given string recursively

I have several alphanumeric strings like these

    listOfNum = [&#39;000231512-n&#39;,&#39;1209123100000-n00000&#39;,&#39;alphanumeric0000&#39;, &#39;000alphanumeric&#39;]

The desired output for removing **trailing** zeros would be:

    listOfNum = [&#39;000231512-n&#39;,&#39;1209123100000-n&#39;,&#39;alphanumeric&#39;, &#39;000alphanumeric&#39;]

The desired output for **leading** trailing zeros would be:

    listOfNum = [&#39;231512-n&#39;,&#39;1209123100000-n00000&#39;,&#39;alphanumeric0000&#39;, &#39;alphanumeric&#39;]

The desire output for removing both leading and trailing zeros would be:

    listOfNum = [&#39;231512-n&#39;,&#39;1209123100000-n&#39;, &#39;alphanumeric&#39;, &#39;alphanumeric&#39;]

For now i&#39;ve been doing it the following way, please suggest a better way if there is:

    listOfNum = [&#39;000231512-n&#39;,&#39;1209123100000-n00000&#39;,&#39;alphanumeric0000&#39;, \
    &#39;000alphanumeric&#39;]
    trailingremoved = []
    leadingremoved = []
    bothremoved = []
    
    # Remove trailing
    for i in listOfNum:
      while i[-1] == &quot;0&quot;:
        i = i[:-1]
      trailingremoved.append(i)
    
    # Remove leading
    for i in listOfNum:
      while i[0] == &quot;0&quot;:
        i = i[1:]
      leadingremoved.append(i)
      
    # Remove both
    for i in listOfNum:
      while i[0] == &quot;0&quot;:
        i = i[1:]
      while i[-1] == &quot;0&quot;:
        i = i[:-1]
      bothremoved.append(i)

How to remove leading and trailing zeros in a string? Python

How do you do a *verbatim* string literal in VB.NET?

This is achieved in C# as follows:

    String str = @&quot;c:\folder1\file1.txt&quot;;

This means that the backslashes are treated literally and not as escape characters.

How is this achieved in VB.NET?


How to do a verbatim string literal in VB.NET?

I would like to parse strings like `1` or `32.23` into integers and doubles. How can I do this with Dart?

Content Type	Original Author	Original Content on Stackoverflow
Question	user965369	View Question on Stackoverflow
Solution 1 - C++	Kerrek SB	View Answer on Stackoverflow
Solution 2 - C++	Luchian Grigore	View Answer on Stackoverflow
Solution 3 - C++	David	View Answer on Stackoverflow

What exactly is the L prefix in C++?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Override Vagrant configuration settings locally (per-dev)

how to overwrite css style

Attributions