extern in macro

[TubularX]

I'm using a library that provides some macros that adds overrided methods, etc.

#include "lib.h"

class MyClass : public LibBase
{
    MACRO( MyClass )
};

This works fine, but I would like to put MyClass into a namespace.

namespace mynamespace
{
    class MyClass : public LibBase
    {
        MACRO( MyClass )
    };
}

The problem is that inside the macro, there is a line like:

extern LibClass var;

Now, this adds a declaration to the namesspace, resulting in an error (unresolved external symbol "LibClass mynamespace::var").

Is it possible to make mynamespace::var refer to (or be an alias for) the global namespace var?

Or can you suggest some workaround?

[2kaud]

Have you tried

extern LibClass ::var;

[TubularX]

Thanks 2kaud!!

Yes, the solution was to have both "extern LibClass var;" and "extern LibClass ::var;" inside the namespace.

Hmm.. but how/why does that work?

Visual Studio's Intellisense shows them as "var" and "mynamespace::var", as if they were two different variables. Of course, there's only one definition. However, if someone later defines a variable "var" inside the namespace, that one would suddenly be referenced instead, right?

[superbonzo]

uhm, I don't think that's a portable solution ... it seems a VS non standard extension

[TubularX]

uhm, I don't think that's a portable solution ... it seems a VS non standard extension

Bummer. Can anyone confirm?

Is there any other solution to my problem?

[superbonzo]

Bummer. Can anyone confirm?

if your current solution is something like

int var;
namespace n {
	extern int var;
	extern int ::var;

	int foo(){ return var; }
}
int main(){ n::foo(); }

then I confirm it doesn't compile in my copy of gcc and clang. As far as I recall, a simple declarator cannot be qualified ( in fact, both compilers complain at "::var" )

Is there any other solution to my problem?

can you post the macro definition ? ( or something equivalent yet complete ? )

[TubularX]

if your current solution is something like

int var;
namespace n {
	extern int var;
	extern int ::var;

	int foo(){ return var; }
}
int main(){ n::foo(); }

No, that code doesn't compile in Visual Studio either.

At least in VS, the order is important. It only works like this:

int var;
namespace n {
	extern int ::var;
	extern int var;

	int foo(){ return var; }
}
int main(){ n::foo(); }

I don't have Microsoft extensions enabled. I compile with the /Za compiler option (emits an error for language constructs that are not compatible with ANSI C89 or ISO C++11).

So, if this is not standard behaviour, it must be a bug in the compiler...?

[TubularX]

can you post the macro definition ? ( or something equivalent yet complete ? )

OK, so here's some simplified code of my scenario:

main.cpp

#include "lib.h"

namespace n
{
	class MyClass : LibBase
	{
		MACRO_DECL( MyClass )
	};

	MACRO_DEF( MyClass )
}

int main()
{
	n::MyClass x;
}

lib.h

#ifndef include_guard
#define include_guard

class LibClass
{
public:
	LibClass() {}
};

class LibBase
{
public:
	LibBase( LibClass* ) {}
};

#define MACRO_DECL( name ) \
public: \
name(); \

#define MACRO_DEF( name ) \
extern LibClass* var; \
name::name() : LibBase(var) {}

extern LibClass* var;

#endif

lib.cpp

#include "lib.h"
LibClass* var = nullptr;

[superbonzo]

At least in VS, the order is important. It only works like this:

this does not compile either ( in clang ), and I'm pretty confident that it's non standard because simple declarators cannot be qualified names; I don't think it's bug though, probably it's just one of the many VS "convenience" feature ...

OK, so here's some simplified code of my scenario:

if you cannot change the lib code, nor the way it's used ( eg. define a global MyLibBase hiding the var passing mechanism ), nor intercept the code where the global var is set, the only workaround I can see is to manually link the extern var declared in mynamespace with the global one, via a linker script ( I don't known if VS linker can do that though ... )

[2kaud]

the only workaround I can see

Just say 'Thank you MS' and comment the code that this is VS only.

[TubularX]

I came up with a solution that I believe will work in all compilers:

namespace n
{
	class MyClass : LibBase
	{
		MACRO_DECL( MyClass )
	};
}

using n::MyClass;
MACRO_DEF( MyClass )

[2kaud]

[superbonzo]

I came up with a solution that I believe will work in all compilers:

the problem is that it somewhat reduces the benefit of using a namespace in the first place ( that is, limiting name clashes ) ...

[TubularX]

the problem is that it somewhat reduces the benefit of using a namespace in the first place ( that is, limiting name clashes ) ...

The code posted was just a simplified example.

In the real codebase the lines

using n::MyClass;
MACRO_DEF( MyClass )

will be put into a cpp file to limit the scope, so it's no problem.

[superbonzo]

will be put into a cpp file to limit the scope, so it's no problem.

I understand, my point is that using-declarations do not hide names ( as declarations do at namespace scope ), they'll just raise a compiler error when a clashing name exists, eg, if your cpp includes some headers containing a clashing name at global scope; this would never happen when defining members in their own namespace ...