C++总结

标示符：数字、字母、下划线  （开头只能是字母和下划线）（不要和关键字重复）
变量、常量：和C一样
const :const int size=20;//size就是20了 
书上： const int * FuncA()
{
static int x=1;
++x;
return &x;
}
void main()
{
int y;
y=*FuncA();  //合法，将值x赋给y
*FuncA()=2;//非法：不能改变一个常量类型的值，函数的返回值是个常量
}
指针和引用：<数据类型>*<指针名>    <数据类型>&<引用名>
指针开辟内存空间，引用不是，是取别名，指针可移动，引用不可以
数组：一维，多维。   利用数组编程时，一定要用到循环
字符串：末尾有‘\0'  注意‘’ 和“ ”的区别 。char s[]={"Hello"};  char* ps='Hello';  //区别：s是字符数组，ps是字符指针
流程控制：1顺序控制语句
   2选择控制语句 if...else   switch   
   3循环控制语句while  do while();  for
   4跳转语句 break continue goto
函数：
定义  类型 函数名 （形式参数表）
{
函数体；
}
调用 函数名（实际参数表）  g1(50) g2(x)...
C++面向对象特性：
封装：增强安全性和简化编程，不必了解实现细节，通过调用外部接口使用类的成员
class Clock
{
public:
void SetTime(int NewH,int NewM,int NewS);
void ShowTime();
private:
int Hour,Minute,Second;
}
多态：多种形态 允许子类类型的指针赋值给弗雷类型的指针  （父类必须是virtual虚函数）
class 类名{
public:
virtual 成员函数说明；
}
example:
class A
{
public:
virtual void foo() { cout<< "Now A::foo() is called!"<<endl; }
};
class B:public A
{
public：
virtual void foo() { cout<<"Now B::foo() is called!"<<endl; }
}
A*a=new B();
a->foo();  //a虽然只想A的指针，由于被调用的foo函数为虚函数，所以,被调用的函数foo()实际上是B的
继承：利用已有的成果，减少工作量，实现代码复用》
派生类 class <派生类名><派生方式><基类名>
{
派生类成员声明；
}
example:
class A
{
private:
int s;
public:
void inits(int n) { s=n }
int gets() { return s; }
}；
class B: public A  //B继承类A公有的
{
private:
int t;
public:
void initt (int n) { t=n; }
int gett() {return t* gets(); }
};
注意访问权限，public 都可以 private friend友元可以 protected 亲缘关系可以
C++特性
结构：struct player
{
int number;
char* name;
char* nationality;
}
两种初始化方式：
struct player A={5,"xiaopang","china");
A.number=5;A.name=“xiaopang";A.nationality="chian";
类：class 类名
{
private:
public:
protected:
};
类和结构区别：类默认私有，结构默认公有  初始化不同 类为构造函数  注意class的末尾；
（类中）构造函数和析构函数：构造函数 与类名相同 构造函数不能被定义类型 不返回值的void也不可以
一个类可以有多个构造函数，这些构造函数必须具有不同的参数表
（类中）析构函数：~开头，与类名相同，每一个类只能有一个析构函数，析构函数不能有参数，并且也不能有返回值（作用：清理工作，释放堆中分配的内存）
#include "iostream"
class Box
{
private:
int height,width,depth;
public:
Box(int ht=2,int wd=3,int dp=4)
{
height=ht;
width=wd;
depth=dp;
}
~Box();
int volume()
{
return height*width*depth;
}
};
int main()
{
Box thisbox(3,4,5);        //初始化
Box defaulBox;//使用默认参数
cout<<thisbox.volume()<<endl;//输出60
cout<<defaulbox.volume()<<endl;//输出24
return 0;
}

纯虚函数virtual void f=0  记住：=0  含有纯虚函数的是 抽象类  纯虚函数为了给派生类来实现方法

class<类名>

{

virtual <类名><函数名>(<参数表>)=0;

};

函数重载，隐藏，覆盖：
重载：1函数名相同 2相同的范围 3参数类型不同或参数个数不同 4 virtual 可有可无 为了实现不同数据类型完成同样的功能（通用性）在同一个类中
覆盖：（覆盖是派生类函数覆盖基类函数）1不同的范围（分别位于派生类和基类） 2函数名字相同 3参数相同 4基类必须含有virtual关键字
#include<iostream>
class Base
{
public:
void f(int x){ cout<<"Base::f(int)"<<x<<endl; }
void f(float x){ cout<<"Base""f(float)"<<x<<endl;}
virtual void g(void){cout<<"Base::g(void)"<<endl;}
}；
class Derived: public Base
{
public:
virtual void g(void) {cout<<"Derived::g(void)"<<endl；}
}；
void main(void)
{
Derived d;
Base* pb=&d;
pd->f(42);   //Base::f(int) 42
pd->f(3.14f);//Base::f(float) 3.14
pd->g();     //Derived::g(void)
}

隐藏：（派生类函数屏蔽了基类的同名函数）1如果派生类的函数与基类的函数同名，但是参数不同，此时无论有无virtual关键字，基类函数都将被隐藏2如果派生类函数与基类函数同名，并且参数也相同，但是基类没有virtual关键字，此时基类被隐藏

new            <指针变量>new<数据类型>;

3种使用形式  1给单个对象申请分配内存

int *ip; ip=new int;  //ip指向1个未初始化的int型对象

2给单个对象申请分配内存额同时初始化该对象

int *ip; ip=new int(68);  //ip指向1个表示为68的int型对象

3同时给多个对象申请分配内存

int *ip;

ip=new int [5];   //ip指向5个未初始化的int型对象的首地址

for(int i=0;i<5;i++)

 ip[i]=5*i+1;      //给ip指向的5个对象赋值

delete

delete<指针变量> 或 delete [ ]<指针变量>

new delete malloc free 区别  new构造并初始化 delete析构  malloc没初始化 free不析构

this指针 隐式的声明 被声明为*const 因此不能改变它的值，但可改变它所指向对象的值

int CTest::chargethis()

{

CTest temp;

this=temp;                             //非法,不能改变this的值

}

int CTest::getn()

{

return this->n;                     //等价于return n

}