No, it is not possible.

I distinctly remember reading somewhere that nested structured bindings are not allowed for C++17, but they are considering allowing it in a future standard. Can&#39;t find the source though.

No, they aren&#39;t possible; but this is:

    for (auto&amp;&amp; [key, value] : data) {
      auto&amp;&amp; [my_int, my_float] = value;
    }
which is close at least.

I&#39;m trying to figure out the difference between url-loader vs file-loader. What does `DataURl` mean?

&gt; The url-loader works like the file-loader, but can return a DataURL if
&gt; the file is smaller than a byte limit.

Url-loader vs File-loader Webpack

I&#39;m trying to run Kafka message queue on Windows.

I&#39;m usin this tutorial - [https://dzone.com/articles/running-apache-kafka-on-windows-os][1]


  [1]: https://dzone.com/articles/running-apache-kafka-on-windows-os


When i try to run it with comand - .\bin\windows\kafka-server-start.bat .\config\server.properties

and i get an error:
**The input line is too long.
The syntax of the command is incorrect.**

kafka location - C:\kafka_2.11-1.0.0

The input line is too long when starting kafka

Assume I have an object of type

    std::map&lt;std::string, std::tuple&lt;int, float&gt;&gt; data;

Is it possible to access the element types in a nested way (i.e. when used in ranged for loop) like this

    for (auto [str, [my_int, my_float]] : data) /* do something */
   
     

Are nested structured bindings possible?

Assume I have an object of type
<pre><code class="hljs language-c">std::map&#x3C;std::string, std::tuple&#x3C;int, float>> data;
</code></pre>
Is it possible to access the element types in a nested way (i.e. when used in ranged for loop) like this
<pre><code class="hljs language-arduino">for (auto [str, [my_int, my_float]] : data) /* do something */

 
</code></pre>

Consider this piece of code:

    struct Base
    {
        int x;
    };
    
    struct Bar : Base
    {
        int y;
    };
    
    struct Foo : Base
    {
        int z;
    };
    
    Bar* bar = new Bar;
    Foo* foo = new Foo;
    
    Base* returnBase()
    {
    	Base* obj = !bar ? foo : bar;
    	return obj;
    }
    
    int main() {
    	returnBase();
    	return 0;
    }

This doesn&#39;t work under Clang or GCC, giving me :

&gt; error: conditional expression between distinct pointer types ‘Foo*’
&gt; and ‘Bar*’ lacks a cast   Base* obj = !bar ? foo : bar;

Which means for it to compile I have to change the code to : 

    Base* obj = !bar ? static_cast&lt;Base*&gt;(foo) : bar;

Since an implicit cast to a `Base*` exists, what is preventing the compiler from doing so?

In other words, why does `Base* obj = foo;` work without a cast but using the `?:` operator doesn&#39;t? Is it because it&#39;s not clear that I want to use the `Base` part?

Ternary operator implicit cast to base class

I have come across this for-loop layout:

    #include &lt;iostream&gt;
    int main()
    {
        {
            for (int i = 0; i != 10; ++i)
            {
                std::cout &lt;&lt; &quot;delete i-&gt;second;&quot; &lt;&lt; std::endl;
            }
        }
    
        {
            for (size_t i = 0; i &lt; 20; ++i)
            {
                std::cout &lt;&lt; &quot;delete m_indices[i];&quot; &lt;&lt; std::endl;
            }
        }
        return 0;
    }

I was wondering what this extra layer of braces is for? This appears a few times in our code base.



For loop inside its own curly braces

We all know members specified `protected` from a base class can only be accessed from a derived class own instance. This is a feature from the Standard, and this has been discussed on Stack Overflow multiple times:

 - [Cannot access protected member of another instance from derived type&#39;s scope
](https://stackoverflow.com/q/45146025/5470596 &quot;a similar question on Stack Overflow&quot;);
 - [Why can&#39;t my object access protected members of another object defined in common base class?](https://stackoverflow.com/q/17717027/5470596 &quot;a similar question on Stack Overflow&quot;)
 - And others.

But it seems possible to walk around this restriction with member pointers, as user chtz [has shown me](https://stackoverflow.com/a/49538355/5470596 &quot;their answer to a related question&quot;):

    struct Base { protected: int value; };
    struct Derived : Base
    {
        void f(Base const&amp; other)
        {
            //int n = other.value; // error: &#39;int Base::value&#39; is protected within this context
            int n = other.*(&amp;Derived::value); // ok??? why?
            (void) n;
        }
    };

[Live demo on coliru](http://coliru.stacked-crooked.com/a/7680e07f219a73a7 &quot;(external)&quot;)

Why is this possible, is it a wanted feature or a glitch somewhere in the implementation or the wording of the Standard?

---

From comments emerged another question: [if `Derived::f` is called with an actual `Base`](http://coliru.stacked-crooked.com/a/185e06f44865b243), is it undefined behaviour?

Access to protected member through member-pointer: is it a hack?

There is a rather silly problem with the number pi in C and C++. As far as I know `M_PI` defined in `math.h` is not required by any standard.

New C++ standards introduced a lot of complicated math in the standard library - hyperbolic functions, `std::hermite` and `std::cyl_bessel_i`, different random number generators and so on and so forth.

Did any of the &#39;new&#39; standards bring in a constant for pi? If not - why? How does all this complicated math work without it?


I am aware of similar questions about pi in C++ (they are several years and standards old); I would like to know the current state of the problem.

I am also very interested in _why oh why_ C++ still doesn&#39;t have a pi constant but has a lot of more complicated math.

I know that I can define pi myself as `4*atan(1)` or `acos(-1)` or `double pi = 3.14;`. Sure. But why do I still have to do it? How do standard math functions work without pi?

Does C++11, 14, 17 or 20 introduce a standard constant for pi?

When reading how to use std::rand, I found this code on [cppreference.com][1]

    int x = 7;
    while(x &gt; 6) 
        x = 1 + std::rand()/((RAND_MAX + 1u)/6);  // Note: 1+rand()%6 is biased

What is wrong with the expression on the right? Tried it and it works perfectly.

  [1]: http://en.cppreference.com/w/cpp/numeric/random/rand

Why is rand()%6 biased?

Let&#39;s imagine you need to call the following method:

    std::tuple&lt;int, int, int&gt; foo();

In C++17, you can call the function and unpack the tuple in a single line:

    auto [a, b, c] = foo();

Now, how can I proceed to store only `b` and `c` and to discard `a`?

Currently, I&#39;m only aware of two options:


----------


1 - I can use a dummy variable when auto-unpacking

However, the dummy variable will be unused and it will issue a warning, so if I want to silent that warning the code will be quite unpleasant to see:

    #pragma warning(push)
    #pragma warning(disable:4101)
    // ReSharper disable once CppDeclaratorNeverUsed
    auto [_, b, c] = foo();
    #pragma warning(pop)


----------
2 - I can store the whole tuple and use `std::get` to retrieve the reference to the only variables I need. The code is less unpleasant but the syntax is also less straightforward.

Moreover, this code&#39;s size increases by one line for each new value that we want keep in the tuple.

    auto tuple = foo();
    int b = std::get&lt;1&gt;(tuple);
    int c = std::get&lt;2&gt;(tuple);


----------

*Is there another and more straightforward method to unpack only some parameters in a tuple?*

C++17: Keep only some members when tuple unpacking

Is it possible in &quot;modern C++&quot; (C++17 or greater) to pass a string literal as a parameter to a C++ template?

I realize you could do this with constructor argument; I just thought it would be more convenient to have it as a template argument, rather than buried deep in the cpp file. I was curious if maybe this was a new feature of modern C++. See Pseudo code below of what I&#39;m trying to do:

Pseudo-code Example:

    // Header File /////////////////////////
    template&lt;constexpr string Name&gt;
    class ModuleBase {
    public:
        ModuleBase();
        string name;
    };

    class xyz : ModuleBase&lt;&quot;xyz&quot;&gt; {
    public:
        xyz();
    };

    // Cpp File //////////////////////////
    template&lt;string_literal Name&gt;
    ModuleBase&lt;Name&gt;::ModuleBase() {
        name = Name;
    }

    xyz::xyz() : ModuleBase() {

    }


Is it possible in modern C++ to pass a string literal as a parameter to a C++ template?

I&#39;ve been using `std::memcpy` to circumvent *strict aliasing* for a long time.

For example, inspecting a `float`, like [this](https://stackoverflow.com/a/17790026/8157187):

    float f = ...;
    uint32_t i;
    static_assert(sizeof(f)==sizeof(i));
    std::memcpy(&amp;i, &amp;f, sizeof(i));
    // use i to extract f&#39;s sign, exponent &amp; significand

However, this time, I&#39;ve checked the standard, I haven&#39;t found anything that validates this. All I found is [this](http://eel.is/c++draft/basic.types#2):

&gt; For any object (other than a potentially-overlapping subobject) of trivially copyable type T, whether or not the object holds a valid value of type T, the underlying bytes ([intro.memory]) making up the object can be copied into an array of char, unsigned char, or std​::​byte ([cstddef.syn]).&lt;sup&gt;40&lt;/sup&gt; If the content of that array is copied back into the object, the object shall subsequently hold its original value. [ Example:
&gt;
    #define N sizeof(T)
    char buf[N];
    T obj;                          // obj initialized to its original value
    std::memcpy(buf, &amp;obj, N);      // between these two calls to std​::​memcpy, obj might be modified
    std::memcpy(&amp;obj, buf, N);      // at this point, each subobject of obj of scalar type holds its original value
&gt;— end example ]

and [this](http://eel.is/c++draft/basic.types#3):
&gt; For any trivially copyable type T, if two pointers to T point to distinct T objects obj1 and obj2, where neither obj1 nor obj2 is a potentially-overlapping subobject, if the underlying bytes ([intro.memory]) making up obj1 are copied into obj2,&lt;sup&gt;41&lt;/sup&gt; obj2 shall subsequently hold the same value as obj1. [ Example:
&gt;
    T* t1p;
    T* t2p;
    // provided that t2p points to an initialized object ...
    std::memcpy(t1p, t2p, sizeof(T));
    // at this point, every subobject of trivially copyable type in *t1p contains
    // the same value as the corresponding subobject in *t2p

&gt; — end example ]

So, `std::memcpy`ing a `float` to/from `char[]` is allowed, and `std::memcpy`ing between the same trivial types is allowed too.

Is my first example (and the linked answer) well defined? Or the correct way to inspect a `float` is to `std::memcpy` it into a `unsigned char[]` buffer, and using `shift`s and `or`s to build a `uint32_t` from it?

----------

Note: looking at `std::memcpy`&#39;s guarantees may not answer this question. As far as I know, I could replace `std::memcpy` with a simple byte-copy loop, and the question will be the same.

Content Type	Original Author	Original Content on Stackoverflow
Question	Timo	View Question on Stackoverflow
Solution 1 - C++	bolov	View Answer on Stackoverflow
Solution 2 - C++	Yakk - Adam Nevraumont	View Answer on Stackoverflow

Are nested structured bindings possible?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

The input line is too long when starting kafka

Url-loader vs File-loader Webpack

Attributions