Question: from time to time it happens that I want to change a type I defines via **using** by a real class.

For example I here a sample, how I can use a struct the same way as a type:

```
using t_int_pair = std::pair< int, int >;
struct s_int_pair : public std::pair< int, int >
{
    using std::pair< int, int >::pair; // inherit ctor
};

void foo()
{
    auto [a1, a2] = t_int_pair{ 0, 0 };
    auto [b1, b2] = s_int_pair{ 0, 0 };
    // ...
}

```

This works fine.

But: for any reason the same code doesn't work for std::tuple, i.e. this produces a compile error:

```
using t_int_triple = std::tuple< int, int, int >;
struct s_int_triple : public std::tuple< int, int, int >
{
    using std::tuple< int, int, int >::tuple; // inherit ctor
};

void bar()
{
    auto [a1, a2, a3] = t_int_triple{ 0, 0, 0 };
    auto [b1, b2, b3] = s_int_triple{ 0, 0, 0 }; // ERROR: cannot decompose class type 'std::_Tuple_impl<0, int, int>'
    // ...
}

```

Does anyone know, why this happens?

And is there a way to workaround this?

I tested this on Compiler Explorer with clang, gcc and msvc.

Any help is appreciated,

regards,

Zoppo

Answer: 
Assuming the example:

```
void foo(int& arg1, int arg2)
{
}

void bar()
{
    int   arg1 = 4;
    int   arg2 = 2;
    foo(arg1, arg2);
}

```

No, such code will not cause any problem. The scopes of those variables are disjoint, none of them can potentially hide another (or did you mean some other potential problem?).
I'm not sure if you are asking if it's ok use the same name for actual parameters and formal parameters. It won't cause any problems as far as I know whichever you choose pass-by-value or pass-by-reference. The scope of formal parameters' name is their function (let's say its name is `f`), and the scope of actual parameters' name is the function which calls the function f. So they won't interfere each other.