Question

Can I make builtin types like int and double available in a C++ namespace?

#include <complex>

typedef int my_int;

namespace my_namespace {
  namespace std = ::std;  // Works
  using ::my_int;         // Works

  using ::int;            // Fails: "expected unqualified-id before 'int'"
  typedef ::int int;      // Fails: "expected unqualified-id before 'int'"
}

typedef int out::int;     // Fails: "expected unqualified-id before 'int'"

my_namespace::my_int x;            // Works
my_namespace::std::complex<int> c; // Works

// I would like to use this:
my_namespace::int x2;    // Fails: "expected unqualified-id before 'int'" 

I suspect that this is due to a language limitation that forbids the use of qualified identifiers with keywords in them (int in this case) but am hoping that there is some way of exposing these.

Use Case

I am trying to use namespaces to organize types so that an external tool (SWIG) can appropriately wrap functions in another language. For example:

void one_two(int &x, int &y) { x = 1; y = 2; }

In the target language, this could be wrapped as a function that mutates its arguments one_two(x, y), or a function that returns the output x, y = one_two(). I would like some way of “annotating” the arguments to provide SWIG with the intended usage. The cleanest option with the current SWIG implementation is to use a namespace to differentate between the two uses: thus the output version x, y = one_two() could be denoted::

void one_two(out::int &x, out::int &y) { x = 1; y = 2; }

if I could somehow make out::int a synonym for int. (This approach works fine with user-defined types.)

Answer 1

int and friends are keywords in the language. They are not names in the global namespace; they are not names at all as far as the language is concerned. Qualifying them with :: is an error. Trying to name any variable int is also an error. Specifically, see 2.1 paragraph 1 in C++03, and 2.12 paragraph 1 in C++11 (the text is the same):

The identifiers shown in Table 3 are reserved for use as keywords (that is, they
are unconditionally treated as keywords in phase 7):
[ ... ]
int