C++ Primer 5th schrieb:

The access to the overloaded
versions that are not otherwise redefined by the derived class will be the access in
effect at the point of the using declaration.

Hier ein größterer Ausschnitt damit ihr auch wisst worum es geht.

C++ Primer 5th schrieb:

Instead of overriding every base-class version that it inherits, a derived class can
provide a using declaration (§15.5, p. 615) for the overloaded member. A using
declaration specifies only a name; it may not specify a parameter list. Thus, a using
declaration for a base-class member function adds all the overloaded instances of that
function to the scope of the derived class. Having brought all the names into its scope,
the derived class needs to define only those functions that truly depend on its type. It
can use the inherited definitions for the others.
The normal rules for a using declaration inside a class apply to names of
overloaded functions (§15.5, p. 615); every overloaded instance of the function in the
base class must be accessible to the derived class. The access to the overloaded
versions that are not otherwise redefined by the derived class will be the access in
effect at the point of the using declaration.

Hoffe mir kann das jemand erklären.

z.B.

struct base{
  void nufnuf() const {}
  void nifnif() const {}
};

class derived : public base{
  using base::nufnuf; // private!
public:
  using base::nifnif;
};

int main(){
  derived d;
  d.nifnif();
  d.nufnuf(); // Fehler (inaccessible)
}

class base
{
protected:
  void foo();
};

class derived : public base
{
public:
  using base::foo;  // foo ist nun public
};

Das hat dann auch Auswirkungen auf die Sichtbarkeit und das Überschreiben von Funktionen durch die abgeleitete Klasse. Für Beispiele dazu, siehe:
http://en.cppreference.com/w/cpp/language/using_declaration