The most vexing parse is a counterintuitive form of syntactic (syntax) ambiguity resolution in the C++ programming language.
In certain situations, the C++ grammar cannot distinguish between the creation of an object parameter and specification of a function's type. In those situations, the compiler is required to interpret the line as a function type specification.
Example 1:
<pre><code class="lang-cpp">void f(double my_dbl) {
 int i(int(my_dbl));
}
</code></pre>
In the above code the C compiler can misinterpret like this:
<pre><code class="lang-cpp">// A function named i takes an integer and returns an integer.
int i(int my_dbl);
</code></pre>
Solution:
<pre><code class="lang-cpp">// declares a variable of type int
int i((int)my_dbl);
//or
int i(static_cast&lt;int&gt;(my_dbl));
</code></pre>

The most vexing parse is a counterintuitive form of syntactic (syntax) ambiguity resolution in the C++ programming language.

In certain situations, the C++ grammar cannot distinguish between the creation of an object parameter and specification of a function's type. In those situations, the compiler is required to interpret the line as a function type specification.

Example 1:

```cpp
void f(double my_dbl) {
 int i(int(my_dbl));
}
```

In the above code the C compiler can misinterpret like this:

```cpp
// A function named i takes an integer and returns an integer.
int i(int my_dbl); 
```

Solution:

```cpp
// declares a variable of type int
int i((int)my_dbl);
//or
int i(static_cast<int>(my_dbl));
```

Notes for me in C++