C++语法基础01--类（class)

朴灿烈づ我的快乐病毒、 2022-01-15 15:33 771阅读 0赞

***序言***

***难得放暑假，回顾大一这一年所学到的东西，总觉的太繁杂。于是，决定用一个暑假来总结c++,java,android,linux,数据结构，数据库..........***

**1.类的声明与定义：  
 class A  
\{  
.....  
\};  
声明：  
class A;  
定义：  
 class A a;//类C风格  
 A b;  
  
  
2.在类尚未完全定义前，我们可以声明指向该类类型的指针或引用。  
class A;  
A \*a;  
A &b;  
.....  
class A  
\{  
.....  
\};  
应用：  
 class A //相当于声明  
 \{   
 private:  
 A \*a;  
 \};  
  
  
3.指针类成员的访问；  
 class A  
\{  
public:  
int height;  
\};  
  
A \*p;  
p->height;//等价于 (\*p).height  
  
  
4.类的定义不会引起内存分配，每个类对象都有自己的数据成员拷贝，但是，每个类成员函数和静态成员的拷贝只有一份。  
  
  
5.在类内部定义的函数自动成为内联函数，在类外部必须显示用inline;外部定义的inline函数必须和头文件一起，或者在调用它的每一个cpp文件一起。  
 class A  
\{  
public:  
void f()\{cout<<"hello"<<endl;\}  
void f1();  
\};  
  
inline void A::f1()\{cout<<"nihao"<<endl;\}  
  
  
6.const对象只能调用const成员函数（构造函数和析构函数除外），非const对象可调用const和非const成员函数。  
  
  
  
  
7.const成员函数可以被相同参数表的非const成员函数重载。  
class A  
\{  
public:  
void f()const;  
void f();//重载  
  
  
  
  
 \};  
  
9.mutable修饰的类成员可以被任何类成员函数修改，即使是const对象的const成员函数；  
  
  
10.在非const成员函数中，this指向的是该类类型的指针，在const成员函数中,this指向const类类型的指针。  
  
  
11. 点.和->是左结合运算符。  
  
  
12.类的静态数据成员没有进入程序的全局名字空间。static关键字只需在类内部声明即可，否则出错。  
  
  
13.静态数据成员的初始化：  
 class A  
\{  
public:  
 static int x;  
static const int y=13;//法一  
 \};  
  
 int A::x=12;//法二：注意：因为在程序中只能提供一个定义，所以，静态数据成员不应该放在头文件中  
  
  
14.静态数据成员的调用；  
例如13定义了class A;则：  
 A a,\*b;  
a.x;  
A::y;  
b->x;  
  
  
15.静态数据成员可以作为类成员函数的缺省形参  
 class A  
\{  
public:  
static int max;  
static const int min=5;  
int arr\[max\]; //error  
 int arr\[min\]; //ok  
 void f(int m=max); //注意，当定义时只需写void A::f(int m)\{\},否则出错（redefinition of default parameter)  
 \};  
  
  
 int A::max=5;  
  
  
16.静态成员函数不能用const或volatile修饰；静态成员函数没有this指针。  
  
  
17.普通函数指针不能被赋值为成员函数的地址。（因为指向成员函数的指针必须三方面都匹配：参数的类型和个数；返回类型；它所属的类类型。）  
 class A  
\{  
public:  
void f()\{cout<<"hello"<<endl;\}  
  
\};  
  
void (\*pf)();  
pf=&A::f;//error  
 (\*pf)();//error 调用函数指针指向的函数  
  
  
18.类成员指针(不能指向静态类成员）的应用  
 class A  
 \{   
 public:  
void f1()\{cout<<"hello"<<endl;\}  
void f()\{cout<<"nihao"<<endl;\}  
  
  
 \};  
  
  
  
  
  
  
 int main()  
 \{   
 A a;  
A \*p=new A;  
void (A::\*pf)();//定义类成员指针  
pf=&(A::f);  
(a.\*pf)();  
(p->\*pf)();  
pf=&A::f1;  
(a.\*pf)();  //注意和普通函数指针的调用  
(p->\*pf)();  
 return 0;  
  
 \}  
  
19.typedef void (A::\*pf)();  
 pf p1=&(A::f);  
(a.\*p1)();  
  
  
  
20.静态类成员的指针是普通指针，因为他们没有this指针。  
  
  
21.union节省空间的类，每个数据成员都在相同的内存地址开始。分配的存储空间为要包含他最大的数据所需的内存空间。缺省情况下为公有。  
  
  
22.union不能有静态数据成员或引用成员，如过一个类类型定义了构造函数，析构函数，或拷贝函数，则它不能成为union的成员；  
class B  
\{  
......  
\};  
  
  
union A  
\{  
public:  
A()\{\}  
~A()\{\}  
private:  
B b;//error  
 B \*p;//ok  
 static int i;//error;  
 int &r; //error  
 \};  
  
23.嵌套类的名字在其外围类域中是可见的，但在其它类域或名字空间是不可见的。  
除非外围类被声明为嵌套类的友元，否则它没有权利访问嵌套类的私有成员。嵌套类也没有任何特权访问其外围成员（即使是外围公有成员，外围静态公有 ,私有成员除外）；任何对外围非静态成员的访问都要同过外围类的指针，引用或对象来完成；  
 class A  
 \{   
 private:  
 class B  
 \{   
 public:  
 .....  
 \};  
 \};  
  
  
 /\*  
\*等价于如下：  
\*  
\*/  
 class C  
 \{   
 private:  
class D;  
  
 \};  
  
  
 class C::D  
 \{   
 public:  
 .......  
 \};  
  
  
24.嵌套类可以直接访问外围类的静态成员，类型名（typedef名字，枚举类名，或一个类名），枚举值；  
 class A  
\{  
public: //private 也可以  
 typedef int (\*pf)();  
 enum status\{Faulse,True\};  
 private:  
 class B  
 \{   
 public:  
 status s;  
 pf my\_fun;  
 \};  
 \};  
  
  
25.在用户声明的名字空间中定义的类名只在该名字空间的域可见，而在全局或其它名字空间中不可见。  
 namespace myspace  
\{  
class A  
\{  
 ....  
 \};  
 \}  
  
 A a;//error  
 myspace::A a;//ok  
  
名字解析为只从定义处层层向上查找：  
 namespace myspace  
\{  
class A  
\{  
  
 public:  
 void f();  
\};  
 int x=111;  
\}  
  
  
namespace myspace  
\{  
void A::f()  
 \{  
 cout<<x<<endl;//ok  
 cout<<y<<endl;//error  
 \}  
  
 int y;  
 \}  
  
  
26.在函数体内定义的类称为局部类，在局部类中不允许有静态数据成员。  
  
  
27.局部类只能访问在外围局部域中定义的类型名，静态变量以及枚举值。  
 void f(void)  
\{  
 int x=10;  
 class A  
 \{  
 public:  
 void f1()  
 \{  
 cout<<x;//error  
 \}  
 \};  
 \}**