using-declaration

Does anyone know why using-declarations don't seem to work for importing type names from dependent base classes? They work for member variables and functions, but at least in GCC 4.3, they seem to be ignored for types. template <class T> struct Base { typedef T value_type; }; template <class T> struct Derived : Base<T> { // Version 1: error on conforming compilers value_type get(); // Version 2: OK, but unwieldy for repeated references typename Base<T>::value_type get(); // Version 3: OK, but unwieldy for many types or deep inheritance typedef typename Base<T>::value_type value_type; value

This is not a question about the difference between using and typedef for creating type aliases. I would like to provide access to an existing type from a namespace inside a code block or a function. I found two different ways : I can "include" the type with a using declaration : using typename mynamespace::mytype; Or I can create a type alias : typedef mynamespace::mytype mytype; using mytype = mynamespace::mytype; //C++11 Is there any difference ? What are the pros and cons of each syntax ? Which one is the most used/recommended ? Thank you. Related question : Using-declaration of an

What is the difference between these two usage of using keyword: using boost::shared_ptr; and using namespace boost; Alok Save using boost::shared_ptr; Includes only the shared_ptr from the boost namespace in your current namespace. This means you can use the shared_ptr without qualifying it with namespace boost . It is called a using declaration . using namespace boost; Includes all the symbols in the boost namespace in your current scope. This means you can use all the symbols in the boost namespace without qualifying them with namespace boost . It is called as using directive . Why should

In [namespace.udecl]/10 you have the following example: namespace A { int i; } namespace A1 { using A::i; using A::i; // OK: double declaration } void f() { using A::i; using A::i; // error: double declaration } This snippet compiles in clang. The first is a declaration inside a namespace, and the multiple using statements could happen frequently using #includes. The second is inside a definition of a function, and you would never do that unless you made a mistake. You can't define the same symbol twice either, for example, but you can declare several times. The using statement is also more

The derived class hides the name of an overload set from the base class if the derived class has the same name defined, but we can always introduce that overload set back with using-declaration: template <class BASE> class A : public BASE { public: using BASE::some_method; void some_method(); } But what if I introduce all overload sets from variadic base classes? Would I be able to write something like this? template <class... BASES> class A : public BASES... { public: using BASES::some_method...; void some_method(); } I've considered using a helper class like: template <class... BASES> struct

Microsoft compiler (Visual Studio 2017 15.2) rejects the following code: #include <type_traits> struct B { template<int n, std::enable_if_t<n == 0, int> = 0> void f() { } }; struct D : B { using B::f; template<int n, std::enable_if_t<n == 1, int> = 0> void f() { } }; int main() { D d; d.f<0>(); d.f<1>(); } The error is: error C2672: 'D::f': no matching overloaded function found error C2783: 'void D::f(void)': could not deduce template argument for '__formal' note: see declaration of 'D::f' Clang also rejects it: error: no matching member function for call to 'f' d.f<0>(); ~~^~~~ note:

namespace A{ int i; } int main(){ using A::i; using A::i; } VS2010 - compiles fine gcc (ideone) - compiles fine Comeau - gives error ""ComeauTest.c", line 10: error: "i" has already been declared in the current scope using A::i;" $7.3.3/8 - "A using-declaration is a declaration and can therefore be used repeatedly where (and only where) multiple declarations are allowed." The example right there indicates that the code is indeed ill-formed. So, is this a bug in GCC and VS2010? EDIT 2: Remove the multiple using directives as it was unrelated to the query on hand. The example you refer to is