C++ – Should class names reflect namespace name

cdesignnamespacenaming

Is it generally considered good practise for a class name to reflect the namespace name it exists under, or should the namespace name implicitly be considered part of the class name?

For example, suppose I have a collection of classes which all act to filter a class Foo:

class FooFilter
{
    public virtual bool operator()(const Foo& obj) const = 0;
};

Subtypes could be called HappyFooFilter, SadFooFilter, … etc.

Now if we wrap these into a namespace, we have something like:

namespace fooFilter
{
    class FooFilter ...
    class HappyFooFilter ....
    class SadFooFilter ...
    etc ....
}

But this contains a redundancy in the class names (e.g. fooFilter::HappFooFilter). So with the introduction of the namespace fooFilter, should the class names change to reflect this new structure?

namespace fooFilter
{
    class Base ...
    class Happy ....
    class Sad ...
    etc ....
}

Best Answer

The problem is that your example is vague and your names are anemic. If we make them good robust names doesn't the choice become obvious?

namespace ImageFilter
{
     class BasicFace ...
     class HappyFace ...
     class SadFace ...
}

verses

namespace ImageFilter
{
     class BasicFaceImageFilter ...
     class HappyFaceImageFilter ...
     class SadFaceImageFilter ...
}

This smurf naming anti pattern has tempted me in the past as well. I've come to feel it's the result of trying to keep anemic names on life support. Rethink all the names and try again. It's a pain to do but it makes for better code.

Related Solutions

PHP – Dynamic Class Inheritance Techniques

It looks like you are having a design issue here: Tables should not extend the Database Abstraction Layer. Instead the DAL should be injected into the table as a dependency.

abstract class Table {
    protected $dal;

    public function __construct(DAL $dal) {
        $this->dal = $dal;
    }

    // whatever else all tables have in common
}

class Table_User extends Table {
    public function someMethod() {
        $this->dal->someOtherMethod();
    }
}

$table = new MyTable($dal);
$table->someMethod();

That way you will create a DAL at some upper scope and pass it down. This will also allow you to use multiple different database engines at the same time.

Additionally you obviously should not create your tables directly in your controller but let a specialized class do that. For example you could use a factory:

class TableFactory {
    protected $dal;

    public function __construct(DAL $dal) {
        $this->dal = $dal;
    }

    public function createTable($name) {
        $className = 'Table_' . $name;
        return new $className($this->dal);
    }
}

That way you can create a table factory at some point with an injected DAL and pass that table factory around.

$table = $factory->createTable('User');

C# Naming Conflicts – Handling Class Names That Conflict with Framework Names

You can use the using alias directive to avoid having to disambiguate everywhere, e.g.

using HttpRequest = MyCompany.MyProject.HttpRequest;

Best Answer

Related Solutions

PHP – Dynamic Class Inheritance Techniques

C# Naming Conflicts – Handling Class Names That Conflict with Framework Names

Related Topic