It stands for `unsigned`. 

When you declare a constant, you can also specify its type. Another common example is `L`, which stands for `long`. (and you have to put it twice to specify a 64-bit constant). 

Example: `1ULL`.

It helps in avoiding explicit casts.

Integer constants in C and C++ can optionally have several suffixes:

  123u&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;    the value 123 is an unsigned int  
  123l&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;    (that&#39;s a lowercase L) 123 is a signed long  
  123L&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;    ditto  
  123uL&amp;nbsp;&amp;nbsp;&amp;nbsp;   unsigned long  
  123LL&amp;nbsp;&amp;nbsp;&amp;nbsp;   a signed long long, a 64 bit or 128 bit value (depending on the environment)  
  123uLL&amp;nbsp;  unsigned long long

Haskell has been called a &quot;pure functional language.&quot;  

What does &quot;pure&quot; mean in this context? What consequences does this have for a programmer?

What does &quot;pure&quot; mean in &quot;pure functional language&quot;?

&gt; **Possible Duplicate:**  
&gt; [What is the etymology of &amp;#39;slug&amp;#39;?](https://stackoverflow.com/questions/4230846/what-is-the-etymology-of-slug)  

&lt;!-- End of automatically inserted text --&gt;

In CouchDB definitive guide the author used key &quot;slug&quot; in a document.

    {
       &quot;title&quot;: &quot;Hello World&quot;,
       &quot;slug&quot;: &quot;hello_world&quot;
    }

What does &quot;slug&quot; mean and why is it used?


What does &quot;slug&quot; mean

What does the postfix (or suffix) `U` mean for the following values?

    0U
    100U

Meaning of U suffix

<p>What does the postfix (or suffix) <code>U</code> mean for the following values?</p>
<pre><code class="hljs">0U
100U
</code></pre>


What&#39;s the difference between `__PRETTY_FUNCTION__`, `__FUNCTION__`, `__func__`, and where are they documented? How do I decide which one to use?

What&#39;s the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?

#A Hacker&#39;s Tale  
The date is 12/02/10.  The days before Christmas are dripping away and I&#39;ve pretty much hit a major road block as a windows programmer.  I&#39;ve been using AQTime, I&#39;ve tried sleepy, shiny, and very sleepy, and as we speak, VTune is installing.  I&#39;ve tried to use the VS2008 profiler, and it&#39;s been positively punishing as well as often insensible.  I&#39;ve used the random pause technique.  I&#39;ve examined call-trees.  I&#39;ve fired off function traces.  But the sad painful fact of the matter is that the app I&#39;m working with is over a million lines of code, with probably another million lines worth of third-party apps.

I need better tools.  _I&#39;ve read the other topics._  I&#39;ve tried out each profiler listed in each topic.  There simply has to be something better than these junky and expensive options, or ludicrous amounts of work for almost no gain.  To further complicate matters, our code is heavily threaded, and runs a number of Qt Event loops, some of which are so fragile that they crash under heavy instrumentation due to timing delays.  Don&#39;t ask me why we&#39;re running multiple event loops.  No one can tell me.

Are there any options more along the lines of Valgrind in a windows environment?  
Is there anything better than the long swath of broken tools I&#39;ve already tried?  
Is there anything designed to integrate with Qt, perhaps with a useful display of events in queue?   

A full list of the tools I tried, with the ones that were really useful in italics:

 - _AQTime:_ Rather good!  Has some trouble with deep recursion, but the call graph is correct in these cases, and can be used to clear up any confusion you might have.  Not a perfect tool, but worth trying out.  It might suit your needs, and it certainly was good enough for me most of the time.
 - _Random Pause attack in debug mode:_ Not enough information enough of the time.  
A good tool but not a complete solution.
 - _Parallel Studios:_  The nuclear option.  Obtrusive, weird, and crazily powerful.  I think you should hit up the 30 day evaluation, and figure out if it&#39;s a good fit. It&#39;s just darn cool, too.
 - _AMD Codeanalyst:_  Wonderful, easy to use, very crash-prone, but I think that&#39;s an environment thing.  I&#39;d recommend trying it, as it is free.
 - _Luke Stackwalker:_ Works fine on small projects, it&#39;s a bit trying to get it working on ours.  Some good results though, and it definitely replaces Sleepy for my personal tasks.
 - _PurifyPlus:_ No support for Win-x64 environments, most prominently Windows 7.  Otherwise excellent.  A number of my colleagues in other departments swear by it.
 - VS2008 Profiler: Produces output in the 100+gigs range in function trace mode at the required resolution.  On the plus side, produces solid results.
 - GProf: Requires GCC to be even moderately effective.
 - VTune: VTune&#39;s W7 support borders on criminal. Otherwise excellent
 - PIN: I&#39;d need to hack up my own tool, so this is sort of a last resort.
 - Sleepy\VerySleepy: Useful for smaller apps, but failing me here.
 - EasyProfiler: Not bad if you don&#39;t mind a bit of manually injected code to indicate where to instrument.
 - Valgrind: *nix only, but very good when you&#39;re in that environment.
 - OProfile: Linux only.
 - Proffy: They shoot wild horses.

Suggested tools that I haven&#39;t tried:  

 - XPerf:  
 - Glowcode:  
 - Devpartner:  

**Notes:**
Intel environment at the moment.  VS2008, boost libraries.  Qt 4+.  And the wretched humdinger of them all: Qt/MFC integration via trolltech.
&lt;hr/&gt;
**Now:** Almost two weeks later, it looks like my issue is resolved.  Thanks to a variety of tools, including almost everything on the list and a couple of my personal tricks, we found the primary bottlenecks.  However, I&#39;m going to keep testing, exploring, and trying out new profilers as well as new tech.  Why?  Because I owe it to you guys, because you guys rock.  It does slow the timeline down a little, but I&#39;m still very excited to keep trying out new tools.

**Synopsis**  
Among many other problems, a number of components had recently been switched to the incorrect threading model, causing serious hang-ups due to the fact that the code underneath us was suddenly no longer multithreaded.  I can&#39;t say more because it violates my NDA, but I can tell you that this would never have been found by casual inspection or even by normal code review.  Without profilers, callgraphs, and random pausing in conjunction, we&#39;d still be screaming our fury at the beautiful blue arc of the sky.  Thankfully, I work with some of the best hackers I&#39;ve ever met, and I have access to an amazing &#39;verse full of great tools and great people.

Gentlefolk, I appreciate this tremendously, and only regret that I don&#39;t have enough rep to reward each of you with a bounty.  I still think this is an important question to get a better answer to than the ones we&#39;ve got so far on SO.  

As a result, each week for the next three weeks, I&#39;ll be putting up the biggest bounty I can afford, and awarding it to the answer with the nicest tool that I think isn&#39;t common knowledge.  After three weeks, we&#39;ll hopefully have accumulated a definitive profile of the profilers, if you&#39;ll pardon my punning.


**Take-away**  
Use a profiler.  They&#39;re good enough for Ritchie, Kernighan, Bentley, and Knuth. I don&#39;t care who you think you are.  Use a profiler.  If the one you&#39;ve got doesn&#39;t work, find another.  If you can&#39;t find one, code one.  If you can&#39;t code one, or it&#39;s a small hang up, or you&#39;re just stuck, use random pausing.  If all else fails, hire some grad students to bang out a profiler.

&lt;hr/&gt;
**A Longer View**  
So, I thought it might be nice to write up a bit of a retrospective.  I opted to work extensively with Parallel Studios, in part because it is actually built on top of the PIN Tool.  Having had academic dealings with some of the researchers involved, I felt that this was probably a mark of some quality.  Thankfully, I was right.  While the GUI is a bit dreadful, I found IPS to be incredibly useful, though I can&#39;t comfortably recommend it for everyone.  Critically, there&#39;s no obvious way to get line-level hit counts, something that AQT and a number of other profilers provide, and I&#39;ve found very useful for examining rate of branch-selection among other things.  In net, I&#39;ve enjoyed using AQTime as well, and I&#39;ve found their support to be really responsive.  Again, I have to qualify my recommendation:  A lot of their features don&#39;t work that well, and some of them are downright crash-prone on Win7x64.  XPerf also performed admirably, but is agonizingly slow for the sampling detail required to get good reads on certain kinds of applications.  

Right now, I&#39;d have to say that I don&#39;t think there&#39;s a definitive option for profiling C++ code in a W7x64 environment, but there are certainly options that simply fail to perform any useful service.

Beyond Stack Sampling: C++ Profilers

Is it possible to have a template class, which inherit from QObject (and has Q_OBJECT macro in it&#39;s declaration)?

I would like to create something like adapter for slots, which would do something, but the slot can take arbitrary number of arguments (number of arguments depends on the template argument).

I just tried doing it, and got linker errors. I guess gmake or moc is not getting called on this template class. Is there a way to do this? Maybe by explicitly instantiating templates?

QT : Templated Q_OBJECT class

Consider the following example:
        
    #include &lt;iostream&gt;
    using namespace std;

    class Animal
    {
    public:
    	virtual void makeSound() {cout &lt;&lt; &quot;rawr&quot; &lt;&lt; endl;}
    };
    
    class Dog : public Animal
    {
    public:
    	virtual void makeSound() {cout &lt;&lt; &quot;bark&quot; &lt;&lt; endl;}
    };
    
    int main()
    {
        Animal animal;
        animal.makeSound();
    
        Dog dog;
        dog.makeSound();
    
        Animal badDog = Dog();
        badDog.makeSound();
    
        Animal* goodDog = new Dog();
        goodDog-&gt;makeSound();
    }

The output is:

    rawr
    bark
    rawr
    bark

But I thought that surely the output should be &quot;rawr bark **bark** bark&quot;.  What&#39;s with the badDog?

---
Update: You may be interested in [another question of mine][1].


  [1]: https://stackoverflow.com/questions/4405634/learning-c-returning-references-and-getting-around-slicing

Learning C++: polymorphism and slicing

In C99, you can declare a flexible array member of a struct as such:

    struct blah
    {
        int foo[];
    };

However, when someone here at work tried to compile some code using clang in C++, that syntax did not work. (It had been working with MSVC.) We had to convert it to:

    struct blah
    {
        int foo[0];
    };

Looking through the C++ standard, I found no reference to flexible member arrays at all; I always thought `[0]` was an invalid declaration, but apparently for a flexible member array it is valid. Are flexible member arrays actually valid in C++? If so, is the correct declaration `[]` or `[0]`?

Are flexible array members valid in C++?

One of the things which I miss while writing programs in C is a dictionary data structure. What&#39;s the most convenient way to implement one in C? I am not looking for performance, but ease of coding it from scratch. I don&#39;t want it to be generic either -- something like `char*`→`int` will do. But I do want it to be able to store an arbitrary number of items. 

This is intended more as an exercise. I know that there are 3rd party libraries available which one can use. But consider for a moment, that they don&#39;t exist. In such a situation what&#39;s the quickest way you can implement a dictionary satisfying the above requirements.

Quick Way to Implement Dictionary in C

Having namespaces seems like no-brainer for most languages. But as far as I can tell, ANSI C doesn&#39;t support it. Why not? Any plans to include it in a future standard?

Why doesn&#39;t ANSI C have namespaces?

I am trying to understand the difference between [`memcpy()`][1] and [`memmove()`][2], and I have read the text that `memcpy()` doesn&#39;t take care of the overlapping source and destination whereas `memmove()` does.

However, when I execute these two functions on overlapping memory blocks, they both give the same result. For instance, take the following MSDN example on the `memmove()` help page:-

Is there a better example to understand the drawbacks of `memcpy` and how `memmove` solves it?

    // crt_memcpy.c
    // Illustrate overlapping copy: memmove always handles it correctly; memcpy may handle
    // it correctly.

    #include &lt;memory.h&gt;
    #include &lt;string.h&gt;
    #include &lt;stdio.h&gt;

    char str1[7] = &quot;aabbcc&quot;;

    int main( void )
    {
        printf( &quot;The string: %s\n&quot;, str1 );
        memcpy( str1 + 2, str1, 4 );
        printf( &quot;New string: %s\n&quot;, str1 );

        strcpy_s( str1, sizeof(str1), &quot;aabbcc&quot; );   // reset string

        printf( &quot;The string: %s\n&quot;, str1 );
        memmove( str1 + 2, str1, 4 );
        printf( &quot;New string: %s\n&quot;, str1 );
    }


###Output:

    The string: aabbcc
    New string: aaaabb
    The string: aabbcc
    New string: aaaabb

  [1]: http://en.cppreference.com/w/c/string/byte/memcpy
  [2]: http://en.cppreference.com/w/c/string/byte/memmove


memcpy() vs memmove()

As much as I love C and C++, I can&#39;t help but scratch my head at the choice of null terminated strings:

* Length prefixed (i.e. Pascal) strings existed before C
* Length prefixed strings make several algorithms faster by allowing constant time length lookup.
* Length prefixed strings make it more difficult to cause buffer overrun errors.
* Even on a 32 bit machine, if you allow the string to be the size of available memory, a length prefixed string is only three bytes wider than a null terminated string. On 16 bit machines this is a single byte. On 64 bit machines, 4GB is a reasonable string length limit, but even if you want to expand it to the size of the machine word, 64 bit machines usually have ample memory making the extra seven bytes sort of a null argument. I know the original C standard was written for insanely poor machines (in terms of memory), but the efficiency argument doesn&#39;t sell me here.
* Pretty much every other language (i.e. Perl, Pascal, Python, Java, C#, etc) use length prefixed strings. These languages usually beat C in string manipulation benchmarks because they are more efficient with strings.
* C++ rectified this a bit with the `std::basic_string` template, but plain character arrays expecting null terminated strings are still pervasive. This is also imperfect because it requires heap allocation.
* Null terminated strings have to reserve a character (namely, null), which cannot exist in the string, while length prefixed strings can contain embedded nulls.

Several of these things have come to light more recently than C, so it would make sense for C to not have known of them. However, several were plain well before C came to be. Why would null terminated strings have been chosen instead of the obviously superior length prefixing?

**EDIT**: Since some asked for *facts* (and didn&#39;t like the ones I already provided) on my efficiency point above, they stem from a few things:

* Concat using null terminated strings requires O(n + m) time complexity. Length prefixing often require only O(m).
* Length using null terminated strings requires O(n) time complexity. Length prefixing is O(1).
* Length and concat are by far the most common string operations. There are several cases where null terminated strings can be more efficient, but these occur much less often.

From answers below, these are some cases where null terminated strings are more efficient:

* When you need to cut off the start of a string and need to pass it to some method. You can&#39;t really do this in constant time with length prefixing even if you are allowed to destroy the original string, because the length prefix probably needs to follow alignment rules.
* In some cases where you&#39;re just looping through the string character by character you might be able to save a CPU register. Note that this works only in the case that you haven&#39;t dynamically allocated the string (Because then you&#39;d have to free it, necessitating using that CPU register you saved to hold the pointer you originally got from malloc and friends).

None of the above are nearly as common as length and concat.

There&#39;s one more asserted in the answers below:

* You need to cut off the end of the string

but this one is incorrect -- it&#39;s the same amount of time for null terminated and length prefixed strings. (Null terminated strings just stick a null where you want the new end to be, length prefixers just subtract from the prefix.)

Content Type	Original Author	Original Content on Stackoverflow
Question	lovespring	View Question on Stackoverflow
Solution 1 - C++	ruslik	View Answer on Stackoverflow
Solution 2 - C++	wallyk	View Answer on Stackoverflow

Meaning of U suffix

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

What does "slug" mean

What does "pure" mean in "pure functional language"?

Attributions