I'm wondering if there's something like a file-specific namespace in C++. Something like the following:
namespace thisFile
{
// whatever code
};
using namespace thisFile;
where thisFile might get translated to some unique thing, such as:
namespace FAJIW0E0RTI43LNAFWENA
{
// whatever code
};
using namespace FAJIW0E0RTI43LNAFWENA;
or perhaps there is an alternative convenient way to accomplish the same thing (i.e. without manually specifying a unique namespace).
Use anonymous namespace:
namespace {
...
}
Related
Is it any way to omit outer namespace name for some functions from other namespace inside top-level one?
void sample_func();
namespace foo {
void first_func();
namespace bar {
void second_func();
void sample_func();
}
Everything is trivial for first_func(): just typing using foo::first_func; allows to call it just as fist_func();
Everything is simple if I want to call second_func without any prefix: just using foo::bar::second_func; allows to call it as second_func();
But is there any way to call it as bar::second_func();? It will increase code readability - much better to type and see something like bar::sample_func instead of full foo::bar::sample_func without names confusion: obviously using namespace foo::bar is not an option in that case.
UPD I am not interested in importing the whole foo or bar namespace (i. e. using namespace ... directive! I need just some functions from them.
You can use
namespace bar = foo::bar;
to import foo::bar into current namespace as just bar.
Prefix it with the namespace:: or :: if not in a namespace i.e
::sample_func();
foo::first_func();
bar::second_func();
bar::sample_func();
You can use
using namespace foo;
in any declarative region where you wish to use just first_func() and bar::sample_func().
Example:
int main()
{
using namespace foo;
first_func();
bar::sample_func();
}
I'm using a namespace to switch between different versions of my database implementation. My client code should not need to know the details so I use a namespace alias to hide the specific version from the client code.
db_v1.h
namespace db_v1
{
class Database ...
}
db_def.h
#ifdef _DB_V1
#include "db_v1.h"
#endif
namespace db = db_v1;
Now if I want to extend the namespace with additional items, which are not version specific, I would like to add them to the namespace db, but the problem is that I can not use namespace db because it is an alias.
db_global.h
namespace db <-- should be using the namespace for the current version
{
typedef enum
{
OK
} value;
}
Obviously I get an error here because the namespace db already exists, while what I really want is, to extend the namespace without knowing wich version is the current one.
As far as I can see, I would have to put such a defintion into a separate namespace like db_global or I would have to duplicate such symbols in all versions, which I don't really like.
Is there some way to define it such that I can write in the client code something like:
x = db::value::OK;
Maybe
#ifdef _DB_V1
#include "db_v1.h"
#endif
namespace db {
using namespace db_v1;
}
in db_def.h instead of namespace db = db_v1;? This way all contents of db_v1 are imported into db namespace. Obviously, it may be conditionally-compiled:
namespace db {
#ifdef _DB_V1
using namespace db_v1;
#elif defined _DB_V2
using namespace db_v2;
#endif
}
For example, this code works well:
namespace db_v1 {
void foo(){}
}
namespace db_v2 {
void foo(){}
}
namespace db {
using namespace db_v1;
}
namespace db {
typedef enum
{
OK
} value;
}
I understood, that I should not use this in a header file:
using namespace foo;
Because it brings the namespace foo in the global scope for anyone who uses my header file.
Can I prevent this from happening, if I do it in my own namespace? For example like this:
namespace my_lib
{
using namespace foo;
// my stuff
// ...
}
Now the using namespace foo should be restricted to the scope of the namespace my_lib, right?
Yes. That is better than using using namespace foo at global level.
Yet better would be if you use foo::name syntax.
Now the using namespace foo should be restricted to the scope of the namespace my_lib, right?
Yes. It brings all the names from the namespace foo in the namespace my_lib which might cause name collisions in my_lib. That is why foo::name is the most preferrable approach.
Yes, if you do that then it just brings all the names from foo into my_lib -- which, as others have pointed out, may or may not be desirable.
One thing I would observe in addition to what others have said is that you can use the 'using directive within a namespace' idea as a way of simulating a using directive that is restricted to class scope. Note that this is illegal:
class C
{
using namespace boost; // for example
// ...
};
But you can do this instead:
namespace C_Namespace {
using namespace boost;
class C
{
};
}
using C_Namespace::C; // bring C itself back into the global namespace
Just thought you might find it useful if what you really want is to be able to define something (like a class) without writing a particular namespace prefix the whole time.
With using namespace I make the whole contents of that namespace directly visible without using the namespace qualifier. This can cause problems if using namespace occurs in widely used headers - we can unintendedly make two namespaces with identical classes names visible and the compiler will refuse to compile unless the class name is prepended with the namespace qualifier.
Can I undo using namespace so that the compiler forgets that it saw it previously?
No, but you can tell your coworkers that you should never have a using directive or declaration in a header.
As others said, you can't and the problem shouldn't be there in the first place.
The next-best thing you can do is bring in your needed symbols so that they are preferred by the name look-up:
namespace A { class C {}; }
namespace B { class C {}; }
using namespace A;
using namespace B;
namespace D {
using A::C; // fixes ambiguity
C c;
}
In some cases you can also wrap the offending includes with a namespace:
namespace offender {
# include "offender.h"
}
No, C++ Standard doesn't say anything about "undo". The best you are allowed to do is to limit scope of using:
#include <vector>
namespace Ximpl {
using namespace std;
vector<int> x;
}
vector<int> z; // error. should be std::vector<int>
But unfortunately using namespace Ximpl will bring all names from std namespace as well.
Not to my knowledge... But as a rule I only use "using namespace" in .cpp files.
The closest, that I'll try to use in header files is following:
//example.h
#ifndef EXAMPLE_H_
#define EXAMPLE_H_
/**
* hating c++ for not having "undo" of using namespace xx
*/
#define string std::string
#define map std::map
class Example {
public:
Example (const char *filename);
Example (string filename);
~Example ();
private:
map<string,complicated_stuff*> my_complicated_map;
};
#undef string
#undef map
#endif //EXAMPLE_H_
after all, defines are #undef -able.
There are 2 problems:
1. it is ugly
2. separate #define and #undef for each name from the corresponding namespace are used
As stated you should not use using namespace sth in header files. When you need functionality from a namespace in your implementation you can leverage scopes like this:
void func() {
// some code agnostic to your namespace.
{
using namespace sth;
// some code aware of sth.
}
// some other code agnostic to your namespace.
}
In c++ Is it OK to include same namespace twice?
compiler wont give any error but still will it affect in anyway
Thanks,
EDIT:
I meant
using namespace std;
// . . STUFF
using namespace std;
It depends what you mean by 'include'. Saying:
using namespace std;
...
using namespace std:
is OK. But saying:
namespace X {
...
namespace X {
would create a nested namespace called X::X, which is probably not what you wanted.
This usage is fine, if it's what your talking about:
File: foo.h
namespace tools
{
class Widget
{
...
};
}
file: bar.h
namespace tools
{
class Gizmo
{
...
};
}
Twice in the same class/file? It shouldn't be a problem, but neither should it be necessary. I'd naively assume that you should be able to refactor your code to avoid the issue.
Are you asking whether following is okay ?
using namespace std;
using namespace std;
It is okay but normally I prefer to refer the namespace element with scope resolution.
ex:
std::vector
std::sort
I'm not entirely sure what you mean. You can put multiple classes in a single namespace (that's the whole idea). Each class generally has it's own files, so yes, you can use the same namespace in multiple files.
Though not technically required, it's a good idea to have a directory structure that represents the namespace hierarchy you create.
As for for the using directive: the compiler and/or intellisense most likely gives you a warning (the C# one does), but otherwise there is no effect.