Does inheritance also automatically "inherit" namespaces from its parent?

Question

Just wanted to ask generic question about Namespaces. If class A inherits class B and doesn't explicitly reference (using) B's namespace, do I have to explicitly using B namespace in my calling code to call B's methods from an instance of A? Is this language dependent (C#, C++)?

Ex in C#:

// Namespace X
class A : B 
{
    public void methodA(){...}
}

// Namespace Y
class B
{
    public void methodB(){...}
}

In other code using A:

using X;
// do I need using Y?
...
A obj = new A();
obj.methodB(); // calls methodB() using instance of A
...

Answer 1

if A is in namespace X and B in Y, you can't do

// Namespace X
class A : B 
{
...
};

you need to do:

class A : Y::B 
{
...
};

So you see you had to inherit B using the qualification and there's nothing special going on there. This is in C++ btw.

If A needs anything more from Y it'll need to similarly qualify it.

Anybody using A needs to qualify it with X::A or import everything or just A, depending, to use it - using X::A; or using namespace X;. That has no effect on what happens to the visibility of things inside Y though.

The only thing that might surprise you is Koenig Lookup, so maybe read that.

Answer 2

No namespaces are not inherited by classes in C++ (and in C#). However due to the ADL (Argument Dependent Lookup) you can "inherit" some names from the namespace of a base class.

Here is a demonstrative program

#include <iostream>

namespace N1
{
    struct A {};

    void f( const A & )
    {
        std::cout << "N1::f( const A & )\n" << '\n';
    }
}

namespace N2
{
    struct B : N1::A
    {
        B() { f( *this ); }
    };
}

int main() 
{
    N2::B b;

    return 0;
}

Its output is

N1::f( const A & )

To "inherit" a namespace you can use the using directive in a namespace or in a block scope. For example

namespace N1
{
    struct A {};
}

namespace N2
{
    using namespace N1;

    struct B : A
    {
    };
}

Take into account that you may not use the using directive in a class scope.

Or you can introduce only some names by means of a using declaration.

Answer 3

Classes do not inherit namespaces. using only imports the symbols in a namespace into the current source file. It has no effect on your classes themselves.

This C# code:

using System;

public class A {
    public void Run() {
        Console.WriteLine("Foobar");
    }
}

Is completely equivalent in its effects, both in the CIL emitted as well as how users of A will use the class or derive it, to this code:

public class A {
    public void Run() {
        System.Console.WriteLine("Foobar");
    }
}

Let's say that we import a type that we return from a method:

using System.IO;

public class A {
    public Stream createStream() {
        // implementation irrelevant
    }
}

If we then declare class B : A in another source file, the createStream() method is inherited, and it still returns System.IO.Stream, even if the source file B is declared in doesn't have using System.IO, and users of class B do not need to import System.IO in order to use the stream returned by createStream(); the system knows the fully-qualified type is System.IO.Stream.

public class B : A {
    public void doSomethingWithStream() {
        // We can use a System.IO.Stream object without importing System.IO
        using (var s = createStream()) {
        }
    }
}

public class C {
    public static void doSomethingElseWithStream(B b) {
        // As can other stuff that uses B.
        using (var s = b.createStream()) {
        }
    }
}

Answer 4

No, there is no such thing as a inherited namespace. Namespace does not have anything that can be derived/inherited.

If you want to inherit a class A that is in different namespace, you need to add "using namespace ..."