`uint32_t` is standard, `uint32` is not.  That is, if you include `&lt;inttypes.h&gt;` or `&lt;stdint.h&gt;`, you will get a definition of `uint32_t`.  `uint32` is a typedef in some local code base, but you should not expect it to exist unless you define it yourself.  And defining it yourself is a bad idea.

`uint32_t` is defined in the standard, in 

### 18.4.1 Header `&lt;cstdint&gt;` synopsis [cstdint.syn]

    namespace std {
    //...
    typedef unsigned integer type uint32_t; // optional
    //...
    }

`uint32` is not, it&#39;s a shortcut provided by some compilers (probably as `typedef uint32_t uint32`) for ease of use.

I am trying to configure my app to support push notification, but keep getting this error:
Failed to get token, error: Error Domain=NSCocoaErrorDomain Code=3000 &quot;no valid &#39;aps-environment&#39; entitlement string found for application&quot; UserInfo=0x1f818fc0 {NSLocalizedDescription=no valid &#39;aps-environment&#39; entitlement string found for application}

- I did enable my app to support push notifications (only for development at this point).
- I did create the provisioning profile AFTER enabling the push notifications.
- My bundle identifier is the same as appears in the profile.
- In my profile file there is a string: &lt;key&gt;aps-environment&lt;/key&gt;
- I made sure that in both project and target under the &quot;Code signing identity&quot; section ALL the values are selected to be my provisioning profile.

Any more ideas? Thanks.

no valid &#39;aps-environment&#39; entitlement string found for application

How does one get a random number within a range similar to c# Random.Next(int min, int max);

How to get a random number from range in dart?

&gt; **Possible Duplicate:** \
&gt; [Difference between different integer types](https://stackoverflow.com/questions/11786113/difference-between-different-integer-types)  

&lt;!-- End of automatically inserted text --&gt;

What is the difference between *uint32* and *uint32_t* in C/C++?

Are they OS-dependent?

In which case should I use one or another?





Difference between uint32 and uint32_t

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/11786113/difference-between-different-integer-types" target="_blank" rel="noopener noreferrer">Difference between different integer types</a>

What is the difference between uint32 and uint32_t in C/C++?
Are they OS-dependent?
In which case should I use one or another?

From Stroustrup&#39;s TC++PL, 3rd Edition, Section 21.3.3:  

&gt; If we try to read into a variable v and the operation fails, the value of v should be unchanged (it is unchanged if v is one of the types handled by istream or ostream member functions).

The following example appears to contradict the above quote.  Based on the above quote, I was expecting the value of v to remain unchanged -- but it gets zeroed.  What&#39;s the explanation for this apparent contradictory behaviour?

    #include &lt;iostream&gt;
    #include &lt;sstream&gt;
    
    int main( )
    {
        std::stringstream  ss;
    
        ss  &lt;&lt; &quot;The quick brown fox.&quot;;
    
        int  v = 123;
    
        std::cout &lt;&lt; &quot;Before: &quot; &lt;&lt; v &lt;&lt; &quot;\n&quot;;
    
        if( ss &gt;&gt; v )
        {
            std::cout &lt;&lt; &quot;Strange -- was successful at reading a word into an int!\n&quot;;
        }
    
        std::cout &lt;&lt; &quot;After: &quot; &lt;&lt; v &lt;&lt; &quot;\n&quot;;
    
        if( ss.rdstate() &amp; std::stringstream::eofbit  ) std::cout &lt;&lt; &quot;state: eofbit\n&quot;;
        if( ss.rdstate() &amp; std::stringstream::failbit ) std::cout &lt;&lt; &quot;state: failbit\n&quot;;
        if( ss.rdstate() &amp; std::stringstream::badbit  ) std::cout &lt;&lt; &quot;state: badbit\n&quot;;
        
        return 1;
    }

The output I get using x86_64-w64-mingw32-g++.exe (rubenvb-4.7.2-release) 4.7.2 is:

    Before: 123
    After: 0
    state: failbit

Thanks.



Why does stringstream &gt;&gt; change value of target on failure?

What is the best method to go about passing a `shared_ptr` of a derived type to a function that takes a `shared_ptr` of a base type?

I generally pass `shared_ptr`s by reference to avoid a needless copy:

    int foo(const shared_ptr&lt;bar&gt;&amp; ptr);

but this doesn&#39;t work if I try to do something like

    int foo(const shared_ptr&lt;Base&gt;&amp; ptr);

    ...

    shared_ptr&lt;Derived&gt; bar = make_shared&lt;Derived&gt;();
    foo(bar);

I could use

    foo(dynamic_pointer_cast&lt;Base, Derived&gt;(bar));

but this seems sub-optimal for two reasons:

- A `dynamic_cast` seems a bit excessive for a simple derived-to-base cast.
- As I understand it, `dynamic_pointer_cast` creates a copy (albeit a temporary one) of the pointer to pass to the function.

Is there a better solution?

## Update for posterity:

It turned out to be an issue of a missing header file. Also, what I was trying to do here is considered an antipattern. Generally,

- Functions that don&#39;t impact an object&#39;s lifetime (i.e. the object remains valid for the duration of the function) should take a plain reference or pointer, e.g. `int foo(bar&amp; b)`.

- Functions that *consume* an object (i.e. are the final users of a given object) should take a `unique_ptr` by value, e.g. `int foo(unique_ptr&lt;bar&gt; b)`. Callers should `std::move` the value into the function.

- Functions that extend the lifetime of an object should take a `shared_ptr` by value, e.g. `int foo(shared_ptr&lt;bar&gt; b)`. The usual advice to avoid [circular references](https://en.wikipedia.org/wiki/Circular_reference) applies.

See Herb Sutter&#39;s [Back to Basics talk](https://www.youtube.com/watch?v=xnqTKD8uD64) for details.

Passing shared_ptr&lt;Derived&gt; as shared_ptr&lt;Base&gt;

I have found it useful to use forward declaration of classes in combination with `std::unique_ptr` as in the code below. It compiles and works with GCC, but the whole thing seem kind of strange, and I wonder if this is standard behaviour (i.e. required by the standard)? Since B isn&#39;t a complete type when I declare the `unique_ptr`.

###A.hpp
    #include &lt;memory&gt;

    class B;

    class A {
        std::unique_ptr&lt;B&gt; myptr;
        // B::~B() can&#39;t be seen from here
    public:
        ~A();
    };

###A.cpp
    #include &quot;B.hpp&quot;
    //B.hpp has to be included, otherwise it doesn&#39;t work.

    A::~A() = default; // without this line, it won&#39;t compile 
    // however, any destructor definiton will do.

I suspect this has to do with the destructor (and therefore the need to call the destructor of `unique_ptr&lt;B&gt;`) is defined in a specific compilation unit (A.cpp).

Forward declaration with unique_ptr?

I have a `QLineEdit` where the user should input only numbers. 

So is there a numbers-only setting for `QLineEdit`?

Set QLineEdit to accept only numbers

I am coding in Eclipse and have something like the following:


    #include &lt;ftream&gt;
    #include &lt;iostream&gt;

    void read_file(){
        char buffer[1025];
        std::istringstream iss(buffer);
    }

However, when I try to build, I get the following error: `variable &#39;std::istringstream iss&#39; has initializer but incomplete type`

Any quick thoughts? I have googled around and it seems like most people with this problem simply did not include the right header files which I believe I am doing correctly. 

C++ compile error: has initializer but incomplete type

The dot (`.`) operator is used to access a member of a struct, while the arrow operator (`-&gt;`) in C is used to access a member of a struct which is referenced by the pointer in question.

The pointer itself does not have any members which could be accessed with the dot operator (it&#39;s actually only a number describing a location in virtual memory so it doesn&#39;t have any members). So, there would be no ambiguity if we just defined the dot operator to automatically dereference the pointer if it is used on a pointer (an information which is known to the compiler at compile time afaik).

So why have the language creators decided to make things more complicated by adding this seemingly unnecessary operator? What is the big design decision?



Why does the arrow (-&gt;) operator in C exist?

I know this doesn&#39;t sound productive, but I&#39;m looking for a way to remember all of the formatting codes for `printf` calls. `%s`, `%p`, `%f` are all obvious, but I can&#39;t understand where `%d` comes from. Is `%i` already taken by something else?

why does %d stand for Integer?

Assuming you&#39;re using a compiler that supports C99 (or even just stdint.h), is there any reason not to use fixed-width integer types such as uint8_t?

One reason that I&#39;m aware of is that it makes much more sense to use `char`s when dealing with characters instead of using `(u)int8_t`s, as mentioned in [this question][1].

But if you are planning on storing a number, when would you want to use a type that you don&#39;t know how big it is? I.e. In what situation would you want to store a number in an `unsigned short` without knowing if it is 8, 16, or even 32 bits, instead of using a `uint16t`?

Following on from this, is it considered better practice to use fixed-width integers, or to use the normal integer types and just never assume anything and use `sizeof` wherever you need to know how many bytes they are using?


  [1]: https://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char

Is there any reason not to use fixed width integer types (e.g. uint8_t)?

If I&#39;ve declared a pointer `p` as `int *p`; in main module, I can change the address contained by `p` by assigning `p = &amp;a;` where `a` is another integer variable already declared.
I now want to change the address by using a function as:


    void change_adrs(int*q)
    {
        int *newad;
        q = newad;
    }
If I call this function from main module  

    int main()
    {
        int *p;
        int a = 0;
        p = &amp;a; // this changes the address contained by pointer p
        printf(&quot;The address is %u\n&quot;, p);
        change_adrs(p);
        printf(&quot;The address is %u\n&quot;, p); // but this doesn&#39;t change the address
        return 0;
    }
the address content is unchanged. What&#39;s wrong with using a function for same task?

Changing address contained by pointer using function

Consider the following Linux kernel dump stack trace; e.g., you can trigger a panic from the kernel source code by calling `panic(&quot;debugging a Linux kernel panic&quot;);`:

```none
[&lt;001360ac&gt;] (unwind_backtrace+0x0/0xf8) from [&lt;00147b7c&gt;] (warn_slowpath_common+0x50/0x60)
[&lt;00147b7c&gt;] (warn_slowpath_common+0x50/0x60) from [&lt;00147c40&gt;] (warn_slowpath_null+0x1c/0x24)
[&lt;00147c40&gt;] (warn_slowpath_null+0x1c/0x24) from [&lt;0014de44&gt;] (local_bh_enable_ip+0xa0/0xac)
[&lt;0014de44&gt;] (local_bh_enable_ip+0xa0/0xac) from [&lt;0019594c&gt;] (bdi_register+0xec/0x150)
```

 - In `unwind_backtrace+0x0/0xf8` what does `+0x0/0xf8` stand for?
 - How can I see the C code of `unwind_backtrace+0x0/0xf8`?
 - How to interpret the panic&#39;s content?  

How to read, understand, analyze, and debug a Linux kernel panic?

I have this expression which returns a `UInt32`:

    let randomLetterNumber = arc4random()%26

I want to be able to use the number in this if statement:

    if letters.count &gt; randomLetterNumber{
        var randomLetter = letters[randomLetterNumber]
    }

This issue is that the console is giving me this


    Playground execution failed: error: &lt;REPL&gt;:11:18: error: could not find an overload for &#39;&gt;&#39; that accepts the supplied arguments
    if letters.count &gt; randomLetterNumber{
       ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~

The problem is that `UInt32` cannot be compared to an `Int`. I want to cast `randomLetterNumber` to an `Int`. I have tried:


    let randomLetterUNumber : Int = arc4random()%26
    let randomLetterUNumber = arc4random()%26 as Int

These both cause `could not find an overload for &#39;%&#39; that accepts the supplied arguments.`

 How can I cast the value or  use it in the if statement?   


    

Content Type	Original Author	Original Content on Stackoverflow
Question	Maxbester	View Question on Stackoverflow
Solution 1 - C++	William Pursell	View Answer on Stackoverflow
Solution 2 - C++	Luchian Grigore	View Answer on Stackoverflow

Difference between uint32 and uint32_t

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

18.4.1 Header `<cstdint>` synopsis [cstdint.syn]

How to get a random number from range in dart?

no valid 'aps-environment' entitlement string found for application

Attributions

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

18.4.1 Header <cstdint> synopsis [cstdint.syn]

How to get a random number from range in dart?

no valid 'aps-environment' entitlement string found for application

Attributions

18.4.1 Header `<cstdint>` synopsis [cstdint.syn]