A non-const reference cannot point to a literal. You cannot bind a literal to a reference to non-const (because modifying the value of a literal is not an operation that makes sense) and only l-values can be bound to references to non-const. You can however bind a literal to a reference to const.

The &quot;const&quot; is important. In this case, a temporary variable is created for this purpose and it&#39;s usually created on stack. 

Environment:
Python 3.6.3
Requests 2.18.4
PyCharm 2018.1

When using the above configuration in normal run everything is fine. However,when using PyCharm debugger my output is constantly giving me two kinds of exceptions:



    Exception ignored in: &lt;generator object urlsplit.&lt;locals&gt;.&lt;genexpr&gt; at 0x7f69803940a0&gt;
    Traceback (most recent call last):
      File &quot;/usr/lib/python3.6/urllib/parse.py&quot;, line 433, in &lt;genexpr&gt;
        if not rest or any(c not in &#39;0123456789&#39; for c in rest):

or 

    SystemError: error return without exception set
    Exception ignored in: &lt;generator object iter_slices at 0x7f69803940f8&gt;
    Traceback (most recent call last):
      File &quot;/home/damian/workspace/DofusV2/venv/lib/python3.6/site-packages/requests/utils.py&quot;, line 449, in iter_slices
        def iter_slices(string, slice_length):
    `
This is not an issue in a single project, I had this issue  in numerous projects countless times. However, every project was multi-threaded ( I do not know if this makes any difference) 
The thing is I do not have this problem when not using the debugger plus it doesn&#39;t really do anything the application is stable and works fine. My question is why is this happening and can I at least suppress it so it won&#39;t pollute my log?

SystemError: error return without exception set, when using requests and debugger

In my Android app i have multiple intent services which run one after another and the very first intent service is trigerred by a broadcast. I came across [Work Manager][1] a few days ago and really liked the simplicity of the Worker and the WorkManager classes. What are the pros and cons of Work Manager over regular intent services? Should i switch to work manager now considering the fact that i may have to write more intent services in the future? Also which option would help me test the code easily?


  [1]: https://developer.android.com/reference/androidx/work/WorkManager

Android Work Manager vs Services?

What is the meaning of the following line? Why is this allowed as 0 is an r-value and not a variable name? What is the significance of `const` in this statement?

    const int &amp;x = 0;

Initialization of a constant reference with a number

What is the meaning of the following line? Why is this allowed as 0 is an r-value and not a variable name? What is the significance of <code>const</code> in this statement?
<pre><code class="hljs language-ini">const int &#x26;x = 0;
</code></pre>

My platform is a Mac. I&#39;m a C++ beginner and working on a personal project which processes Chinese and English. UTF-8 is the preferred encoding for this project.

I read some posts on Stack&amp;nbsp;Overflow, and many of them suggest using `std::string` when dealing with UTF-8 and avoid `wchar_t` as there&#39;s no `char8_t` right now for UTF-8.

However, none of them talk about how to properly deal with functions like `str[i]`, `std::string::size()`, `std::string::find_first_of()` or `std::regex` as these function usually returns unexpected results when facing UTF-8.

Should I go ahead with `std::string` or switch to `std::wstring`? If I should stay with `std::string`, what&#39;s the best practice for one to handle the above problems?



How do I properly use std::string on UTF-8 in C++?

I am moving towards C++11 from C++98 and have become familiar with the `auto` keyword. I was wondering why we need to explicitly declare `auto` if the compiler is able to automatically deduce the type. I know C++ is a strongly typed language and this is a rule but was it not possible to achieve the same outcome without explicitly declaring a variable `auto`?

Why do I need to explicitly write the &#39;auto&#39; keyword?

Is there an equivalent of list slicing `[1:]` from Python in C++ with vectors? I simply want to get all but the first element from a vector.

Python&#39;s list slicing operator:

    list1 = [1, 2, 3]
    list2 = list1[1:]  

    print(list2) # [2, 3]

C++ Desired result:

    std::vector&lt;int&gt; v1 = {1, 2, 3};
    std::vector&lt;int&gt; v2;
    v2 = v1[1:];

    std::cout &lt;&lt; v2 &lt;&lt; std::endl;  //{2, 3}

Slicing a vector in C++

I can&#39;t figure out how to install Windows 10 SDK for Visual Studio 2017.

I downloaded and ran the Windows 10 SDK installer, and it displays `Please find winsdksetup.exe in ....\Windows kits\10\WindowsSDK to install Windows Software Development Kit - Windows 10.0.17134.12.`

When I run `winsdksetup.exe`, it takes me through the same loop, where it downloads a bunch of executable installers into this directory and show the same exact message.

When I try to build a DirectX project in VS2017, I get the error:

    MSB8036	The Windows SDK version 10.0.16299.0 was not found. Install the required version of Windows SDK or change the SDK version in the project property pages or by right-clicking the solution and selecting &quot;Retarget solution&quot;.	

Do I need to install one of those installers? Which one do I need to run to build and debug DirectX projects for Visual Studio? Specifically to use VS2017 shader debugging functionality.

Thanks,

EDIT: 
Under VS2017 - Tools -&gt; Get Tools and Features
I have checked

Game Development with C++

and under Optional I have 

C++ Profiling tools
Windows 10 SDK (10.0.17134.0)

I&#39;m downloading 16299.0, this fixed the first error of not having the right SDK.

But now I get the runtime error `Failed Creating the Direct3D device` when running in Debug. I can still run samples in Release

How do I install Windows 10 SDK for use with Visual Studio 2017

 I saw a weird type of program [here][1].

    int main()
    {
        int s[]={3,6,9,12,18};
        int* p=+s;
    }

Above program tested on **GCC** and **Clang** compilers and working fine on both compilers.

I curious to know, What does `int* p=+s;` do?

Is array `s` decayed to pointer type?

  [1]: https://ideone.com/UbvCp5


What does &quot;int* p=+s;&quot; do?

I am reading a code snippet from a book and find this:

    const char* const &amp; a = &quot;hello&quot;; //can compile 
    const char*&amp; a = &quot;hello&quot;; //cannot

All I know is that when initializing a reference, the *array to pointer conversion* would not take place. 

`const char* const &amp;`, a reference to a `const pointer`, the pointer points to `const char`.

`const char*&amp; `, a reference to a `pointer`, the pointer points to 
`const char`.

So why does adding an extra `const`, indicating that the pointer is a `const`, allow it to compile?

Why can const char* const &amp; = &quot;hello&quot; compile?

    std::tie(a, b) = std::minmax(a, b);


I think this is intuitive code. Clean and understandable. Too bad it doesn&#39;t work as intended, as [`std::minmax`](https://en.cppreference.com/w/cpp/algorithm/minmax) templates for `const&amp;`. If therefore the values are swapped inside the `std::pair&lt;const&amp;, const&amp;&gt;` than one assignement will overwrite the other value:

    auto[a, b] = std::make_pair(7, 5);

    std::tie(a, b) = std::minmax(a, b);

    std::cout &lt;&lt; &quot;a: &quot; &lt;&lt; a &lt;&lt; &quot;, b: &quot; &lt;&lt; b &lt;&lt; &#39;\n&#39;;


&gt; a: 5, b: 5


The expected output here is `a: 5, b: 7`.

----------

I think this is important as implementing transform functions to apply a function onto some ranges requires such statements for intuitive lambdas. For example:

    std::vector&lt;int&gt; v{ 0, 1, 0, 2, 0 };
    std::vector&lt;int&gt; u{ 1, 0, 1, 0, 1 };
    
    perform(v.begin(), v.end(), u.begin(), [](auto&amp; a, auto&amp; b){ 
    	std::tie(a, b) = std::minmax(a, b);    
    }); 

    //v would be == {0, 0, 0, 0, 0}
    //u would be == {1, 1, 1, 2, 1}


----------

 One solution I found was constructing an [`std::tuple`](https://en.cppreference.com/w/cpp/utility/tuple) explicitly without any reference qualifiers over the `std::pair&lt;const&amp;, const&amp;&gt;` to enforce a copy:


    std::tie(a, b) = std::tuple&lt;int, int&gt;(std::minmax(a, b)); 

 But this `&lt;int, int&gt;` redundancy seems rather awful, especially when having said`auto&amp; a, auto&amp; b` before. 


----------


Is there a nice, short way to perform this assignement? Could it be that this is the wrong direction and just saying `if (a &gt;= b) { std::swap(a, b); }` would be the best approach here?


Is there a nice way to assign std::minmax(a, b) to std::tie(a, b)?

As far as I know, reference/pointer aliasing can hinder the compiler&#39;s ability to generate optimized code, since they must ensure the generated binary behaves correctly in the case where the two references/pointers indeed alias. For instance, in the following C code,

```c
void adds(int  *a, int *b) {
    *a += *b;
    *a += *b;
}
```

when compiled by `clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)` with the `-O3` flag, it emits

```none
0000000000000000 &lt;adds&gt;:
   0:    8b 07                    mov    (%rdi),%eax  # load a into EAX
   2:    03 06                    add    (%rsi),%eax  # load-and-add b
   4:    89 07                    mov    %eax,(%rdi)  # store into a
   6:    03 06                    add    (%rsi),%eax  # load-and-add b again
   8:    89 07                    mov    %eax,(%rdi)  # store into a again
   a:    c3                       retq
```

Here the code stores back to `(%rdi)` twice in case `int *a` and `int *b` alias.

When we explicitly tell the compiler that these two pointers cannot alias with the `restrict` keyword:

```c
void adds(int * restrict a, int * restrict b) {
    *a += *b;
    *a += *b;
}
```

Then Clang will emit a more optimized version that effectively does `*a += 2 * (*b)`, which is equivalent if (as promised by `restrict`) `*b` isn&#39;t modified by assigning to `*a`:

```none
0000000000000000 &lt;adds&gt;:
   0:    8b 06                    mov    (%rsi),%eax   # load b once
   2:    01 c0                    add    %eax,%eax     # double it
   4:    01 07                    add    %eax,(%rdi)   # *a += 2 * (*b)
   6:    c3                       retq
```

Since Rust makes sure (except in unsafe code) that two mutable references cannot alias, I would think that the compiler should be able to emit the more optimized version of the code.

When I test with the code below and compile it with `rustc 1.35.0` with `-C opt-level=3 --emit obj`,

```rust
#![crate_type = &quot;staticlib&quot;]
#[no_mangle]
fn adds(a: &amp;mut i32, b: &amp;mut i32) {
    *a += *b;
    *a += *b;
}
```

it generates:

```none
0000000000000000 &lt;adds&gt;:
   0:    8b 07                    mov    (%rdi),%eax
   2:    03 06                    add    (%rsi),%eax
   4:    89 07                    mov    %eax,(%rdi)
   6:    03 06                    add    (%rsi),%eax
   8:    89 07                    mov    %eax,(%rdi)
   a:    c3                       retq
```

This does not take advantage of the guarantee that `a` and `b` cannot alias.

Is this because the current Rust compiler is still in development and has not yet incorporated alias analysis to do the optimization?

Is this because there is still a chance that `a` and `b` could alias, even in safe Rust?


Why does the Rust compiler not optimize code assuming that two mutable references cannot alias?

I was trying to manipulate the field `x` of the struct `Foo` by borrowing a mutable reference from its instance `foo`.

If I try to print the field `x` using the moved binding `y` of the instance `foo` **after** the move of the original instance, it keeps printing the value that haven&#39;t changed.

Simplified example below:
```rust
struct Foo {
    x: i32,
}

fn main() {
    let mut foo = Foo { x: 42 };
    let x = &amp;mut foo.x;
    *x = 13;
    let y = foo;
    println!(&quot;{}&quot;, y.x); // -&gt; 42; expected result: 13
}
```

Instead, if I print the moved binding `y` itself, it prints the changed value.
```rust
println!(&quot;{:?}&quot;, y); // -&gt; Foo { x: 13 }
```
Or, if I print something else like `x` or `foo.x` **before** the move, it prints the thing as expected.
```rust
println!(&quot;{}&quot;, x); // -&gt; 13
let y = foo;
println!(&quot;{}&quot;, y.x); // -&gt; 13
```
Is this an intended behavior?

Changes using mutable reference of a field are not reflected after move of the original instance

An example of how a range gets consumed is:

```rust
let coll = 1..10;
for i in coll {
    println!(&quot;i is {}&quot;, &amp;i);
}
println!(&quot;coll length is {}&quot;, coll.len());
```

This will fail with

```none
error[E0382]: borrow of moved value: `coll`
   --&gt; src/main.rs:6:35
    |
2   |     let coll = 1..10;
    |         ---- move occurs because `coll` has type `std::ops::Range&lt;i32&gt;`, which does not implement the `Copy` trait
3   |     for i in coll {
    |              ----
    |              |
    |              `coll` moved due to this implicit call to `.into_iter()`
    |              help: consider borrowing to avoid moving into the for loop: `&amp;coll`
...
6   |     println!(&quot;coll length is {}&quot;, coll.len());
    |                                   ^^^^ value borrowed here after move
    |
note: this function consumes the receiver `self` by taking ownership of it, which moves `coll`
```

The usual way to fix this is to borrow the `coll`, but that doesn&#39;t work here:

```none
error[E0277]: `&amp;std::ops::Range&lt;{integer}&gt;` is not an iterator
 --&gt; src/main.rs:3:14
  |
3 |     for i in &amp;coll {
  |              -^^^^
  |              |
  |              `&amp;std::ops::Range&lt;{integer}&gt;` is not an iterator
  |              help: consider removing the leading `&amp;`-reference
  |
  = help: the trait `std::iter::Iterator` is not implemented for `&amp;std::ops::Range&lt;{integer}&gt;`
  = note: required by `std::iter::IntoIterator::into_iter`
```

Why is that? Why is a borrowed range not an iterator, but the range is? Is it interpreting it differently?


Why is a borrowed range not an iterator, but the range is?

What is the difference between `const` and `final` keyword in Dart?


What is the difference between the &quot;const&quot; and &quot;final&quot; keywords in Dart?

What&#39;s the best programming practice to 

&gt; create a constant class in Flutter

 to keep all the application constants for easy reference. I know that there is `const` keyword in Dart for creating constant fields, but is it okay to use `static` along with const, or will it create memory issues during run-time.
 
    class Constants {
    static const String SUCCESS_MESSAGE=&quot; You will be contacted by us very soon.&quot;;
    }

What&#39;s the best practice to keep all the constants in Flutter?

    template&lt;typename T&gt;
    void f(T a, const T&amp; b)
    {
        ++a; // ok
        ++b; // also ok!
    }
    
    template&lt;typename T&gt;
    void g(T n)
    {
        f&lt;T&gt;(n, n);
    }
    
    int main()
    {
        int n{};
        g&lt;int&amp;&gt;(n);
    }

Please note: `b` is of `const T&amp;` and `++b` is ok!

**Why is `const T&amp;` not sure to be const?**

Why is `const T&amp;` not sure to be const?

Compiling the following code in Visual Studio 2015 (Win7 , x64, Debug configuration) took **very, very, very** long time (i.e., more than 10 minutes)

    double tfuuuuuuu(int Ind)
    {
      const double Arr[600 * 258] = {3.5453, 45.234234234, 234234.234,// extends to 258 values for each line
                                    // 599 lines here.....
                                    };                     
      return Arr[Ind];
    }

But when I added the `static` keyword, compilation took half a second

    double tfuuuuuuu(int Ind)
    {
      static const double Arr[600 * 258] = {3.5453, 45.234234234, 234234.234,// extends to 258 values for each line
                                    // 599 lines here.....
                                    };                     
      return Arr[Ind];
    }

I know that `static` means that the variable will keep its value between invocations, but if the array is `const` anyway what difference does it make if I add `static`? and why is compilation time changed so dramatically?

***EDIT***  :

The actual code can be found [here][1] , (compilation was in Debug mode)


  [1]: http://1drv.ms/u/s!AjTJR70yilLrg0Ay9AjodTYLEgwt

Content Type	Original Author	Original Content on Stackoverflow
Question	user3112666	View Question on Stackoverflow
Solution 1 - C++	user3112666	View Answer on Stackoverflow

Initialization of a constant reference with a number

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Android Work Manager vs Services?

SystemError: error return without exception set, when using requests and debugger

Attributions