Init

cppdraft/class/name.md

@@ -0,0 +1,108 @@
+[class.name]
+
+# 11 Classes [[class]](./#class)
+
+## 11.3 Class names [class.name]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/classes.tex#L408)
+
+A class definition introduces a new type[.](#1.sentence-1)
+
+[*Example [1](#example-1)*:
+
+struct X { int a; };struct Y { int a; };
+X a1;
+Y a2;int a3; declares three variables of three different types[.](#1.sentence-2)
+
+This implies thata1 = a2; // error: Y assigned to X a1 = a3; // error: int assigned to X are type mismatches, and thatint f(X);int f(Y);declare overloads ([[over]](over "12 Overloading")) named f and not
+simply a single function f twice[.](#1.sentence-3)
+
+For the same reason,struct S { int a; };struct S { int a; }; // error: double definition is ill-formed because it defines S twice[.](#1.sentence-4)
+
+— *end example*]
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/classes.tex#L438)
+
+[*Note [1](#note-1)*:
+
+It can be necessary to use an [*elaborated-type-specifier*](dcl.type.elab#nt:elaborated-type-specifier "9.2.9.5 Elaborated type specifiers [dcl.type.elab]") to refer to a class
+that belongs to a scope in which its name is also bound to
+a variable, function, or enumerator ([[basic.lookup.elab]](basic.lookup.elab "6.5.6 Elaborated type specifiers"))[.](#2.sentence-1)
+
+[*Example [2](#example-2)*: struct stat {// ...};
+
+stat gstat; // use plain stat to define variableint stat(struct stat*); // stat now also names a functionvoid f() {struct stat* ps; // struct prefix needed to name struct stat stat(ps); // call stat function} — *end example*]
+
+An [*elaborated-type-specifier*](dcl.type.elab#nt:elaborated-type-specifier "9.2.9.5 Elaborated type specifiers [dcl.type.elab]") can also be used to declare
+an [*identifier*](lex.name#nt:identifier "5.11 Identifiers [lex.name]") as a [*class-name*](class.pre#nt:class-name "11.1 Preamble [class.pre]")[.](#2.sentence-2)
+
+[*Example [3](#example-3)*: struct s { int a; };
+
+void g() {struct s; // hide global struct s with a block-scope declaration s* p; // refer to local struct sstruct s { char* p; }; // define local struct sstruct s; // redeclaration, has no effect} — *end example*]
+
+Such declarations allow definition of classes that refer to each other[.](#2.sentence-3)
+
+[*Example [4](#example-4)*: class Vector;
+
+class Matrix {// ...friend Vector operator*(const Matrix&, const Vector&);};
+
+class Vector {// ...friend Vector operator*(const Matrix&, const Vector&);};
+
+Declaration of friends is described in [[class.friend]](class.friend "11.8.4 Friends"),
+operator functions in [[over.oper]](over.oper "12.4 Overloaded operators")[.](#2.sentence-4)
+
+— *end example*]
+
+— *end note*]
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/classes.tex#L497)
+
+[*Note [2](#note-2)*:
+
+An [*elaborated-type-specifier*](dcl.type.elab#nt:elaborated-type-specifier "9.2.9.5 Elaborated type specifiers [dcl.type.elab]") ([[dcl.type.elab]](dcl.type.elab "9.2.9.5 Elaborated type specifiers")) can also
+be used as a [*type-specifier*](dcl.type.general#nt:type-specifier "9.2.9.1 General [dcl.type.general]") as part of a declaration[.](#3.sentence-1)
+
+It
+differs from a class declaration in that it can refer to
+an existing class of the given name[.](#3.sentence-2)
+
+— *end note*]
+
+[*Example [5](#example-5)*: struct s { int a; };
+
+void g(int s) {struct s* p = new struct s; // global s p->a = s; // parameter s} — *end example*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/classes.tex#L517)
+
+[*Note [3](#note-3)*:
+
+The declaration of a class name takes effect immediately after the[*identifier*](lex.name#nt:identifier "5.11 Identifiers [lex.name]") is seen in the class definition or[*elaborated-type-specifier*](dcl.type.elab#nt:elaborated-type-specifier "9.2.9.5 Elaborated type specifiers [dcl.type.elab]")[.](#4.sentence-1)
+
+[*Example [6](#example-6)*:
+
+class A * A; first specifies A to be the name of a class and then redefines
+it as the name of a pointer to an object of that class[.](#4.sentence-2)
+
+This means that
+the elaborated form class A must be used to refer to the
+class[.](#4.sentence-3)
+
+Such artistry with names can be confusing and is best avoided[.](#4.sentence-4)
+
+— *end example*]
+
+— *end note*]
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/classes.tex#L534)
+
+A [*simple-template-id*](temp.names#nt:simple-template-id "13.3 Names of template specializations [temp.names]") is only a [*class-name*](class.pre#nt:class-name "11.1 Preamble [class.pre]") if its [*template-name*](temp.names#nt:template-name "13.3 Names of template specializations [temp.names]") names a class template[.](#5.sentence-1)