Can you start a class name with a numeric digit?

Question

In C++, is it possible to start a class name with a digit? For example,

template <class T> class 2DArray {

public:
    // 1D ARRAY CLASS
    class 1DArray {
    public:
        1DArray() { Create(); }
        1DArray(iterator arr) : array1d_(arr) { }
        explicit 1DArray(size_type cols, const T& t = T()) { Create(cols, t); }
        1DArray(const 1DArray& arr) { Create(arr.begin(), arr.end()); }
        1DArray& operator=(const 2DArray&);
        ~1DArray() { Uncreate(); }

        T& operator[](size_type n) {
            return array1d_[n];
        }
        const T& operator[](size_type n) const {
            return array1d_[n];
        }
}

Answer 1

Rules for identifier names in C++ are:

1. It can not start with a number
2. Can be composed of letters, numbers, underscore, universal character names¹ and implementation defined characters
3. Can not be a keyword.

The sections in the C++ draft standard that cover this are 2.11 Identifiers which includes the following grammar:

identifier:
  identifier-nondigit            <- Can only start with a non-digit
  identifier identifier-nondigit <- Next two rules allows for subsequent 
  identifier digit               <-  characters to be those outlined in 2 above
identifier-nondigit:
  nondigit                       <- a-z, A-Z and _ 
  universal-character-name
  other implementation-defined characters
[...]

and 2.12 Keywords explains all the identifier reserved for use as keywords.

Finally, the following names are also reserved:

1. Names that contain a double underscore __, or start with either an underscore followed by an uppercase letter (like _Apple) in any scope,
2. Names that start with an underscore in the global namespace (like _apple in the global namespace) are reserved.

The section that covers this in the draft standard is 17.6.4.3.2. We can find a rationale for why these are reserved from Rationale for International Standard—Programming Languages—C which says:

[...]This gives a name space for writing the numerous behind-the-scenes non-external macros and functions a library needs to do its job properly[...]

In C++ this also applies to name mangling as this example shows.

---

Footnotes

• 1. Allowed universal characters

The universal characters that are allowed is covered in Annex E.1:

E.1 Ranges of characters allowed [charname.allowed]

00A8, 00AA, 00AD,

00AF, 00B2-00B5, 00B7-00BA, 00BC-00BE, 00C0-00D6, 00D8-00F6, 00F8-00FF

0100-167F, 1681-180D, 180F-1FFF 200B-200D, 202A-202E, 203F-2040, 2054,

2060-206F 2070-218F, 2460-24FF, 2776-2793, 2C00-2DFF, 2E80-2FFF

3004-3007, 3021-302F, 3031-303F

3040-D7FF F900-FD3D, FD40-FDCF,

FDF0-FE44, FE47-FFFD

10000-1FFFD, 20000-2FFFD, 30000-3FFFD, 40000-4FFFD, 50000-5FFFD, 60000-6FFFD, 70000-7FFFD, 80000-8FFFD, 90000-9FFFD, A0000-AFFFD, B0000-BFFFD, C0000-CFFFD, D0000-DFFFD, E0000-EFFFD

Answer 2

Since, surprisingly, I wasn't able to find a duplicate, or more general version, of this question, here is an answer based on what the Standard (C++11) says.

First of all, by §9/1, a class name is an identifier (or a simple-template-id in the case of a template specialization, but a simple-template-id is also composed of identifiers).

§2.11 defines what a valid identifier is. It first introduces a few basic concepts:

A digit is one of these: 0 1 2 3 4 5 6 7 8 9
A nondigit is one of these: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
A universal-character-name is a sequence of type \unnnn or \Unnnnnnnn (where each n is a hexadecimal digit)

The Standard then defines an identifier-nondigit as

• either a nondigit
• or a universal-character-name
• or an implementation-defined special character^(‡)

Finally, identifier is defined recursively as

identifier:
  identifier-nondigit
  identifier identifier-nondigit
  identifier digit

Summary: In other words, an identifier must start with a (non-digit!) alphabetical character, which can be followed by anything made up of alphanumerical characters, underscores and \unnnn-like character references. Anything else is implementation-specific.

---

^(‡) Whether any are supported depends on your compiler, and using them generally means you lose portability to other compilers or compiler versions.