计算机 程序设计 C++基础

存储简介

栈，自动分配内存，存储一般变量
堆，自行分配内存，类型名 *p=new 类型名需要delete p清楚内存
全局区，全局变量和static静态变量
常量区，字符串和常量
代码区，系统编译的机器代码

cin>>a;//输入
cout<<a<<endl;//输出并换行
cout<<setw(2)<<a;//输出的东西占两格
cout<<setprecision(2)<<a;//保留小数

分文件

类声明（类名.h），类定义（类名.cpp）
在用到某类的文件，声明#include"类名.h"
引号表示在当前程序目录下寻找文件
＜＞表示在程序默认库搜索，如iostream

引用

类型 &引用名=变量名，意为b为a的引用

int &b=a;//ab地址相同

面向对象

类外实现函数 返回值 类名::函数名(){}

void A::function(){}

函数重载 同名，参数个数或类型不同，与返回值无关

函数默认值 当函数设置默认值（必须从右到左），实际参数个数不同也可调用，自动赋默认值。无默认值时必须指定

对象赋值（拷贝构造函数）
类名 对象名（被拷贝对象名）

A a(b);

类名 对象名=被拷贝对象名（如果对象已实例化则不会调用拷贝构造）

A a=b;

自定义拷贝构造函数
类名：：类名（const 类名&对象名）

A::A(const A&a){}

const保证对象为只读，不可更改

新建函数的参数若为对象，则会再次条用构造函数构造对象，使用&则不会再次构造
调用拷贝构造的情况：参数为对象，函数返回对象，用对象初始化对象

const

char* const p=&a;//不可指向别的
const char* p=&a;//值不可改
const char* const p=&a;//指向和值都不可改

指向不可变的必须先初始化指向，内容不可变的可过后确定指向
const为对象的函数必须也是const的

静态 static

定义静态数据成员 static 数据类型 变量名

static int variable;//类内

静态数据成员必须单独在类外初始化（不加static）
int 类名::变量名=值；

int A::variable=0;

静态数据成员属于类而不属于对象，只有一份，所有对象共同拥有
静态成员函数不能调用非静态成员函数和非静态成员，不可const修饰（参数无this指针）

静态函数可以由类名或对象调用，一般不访问非静态成员（只可通过对象访问）

类名调用 类名::函数名
对象调用 对象名.函数名

A::fun();
a.fun();

对象指针不是对象，不用构造，也不用清除内存

堆中申请内存(需要清除)

类 *p=new 类（）
int *p=new int；
int *arr=new int［10］；delete ［］arr；
类型 名称=new 类型；delete 名称；

int *p=new int;
A *p=new A();
delete p;

int *arr=ne int[10];
delete []arr;

内存中动态分配变量，无名。delete p释放内存，如果不释放则一直占用

友元

友元函数
非成员函数作为友元函数，friend int disp();可访问私有成员

friend void disp();

另一个类的成员函数作为此类的友元函数，声明friend int 类名::disp();
实现不写friend

friend void A::disp();

友元类
x是y的友元类，在y中声明为成员，x可访问y的私有量和函数

初始化列表（仅用于构造函数）

先于函数执行，效率高速度快（常数据成员初始化必须用初始化列表，与常对象区分）（常对象，指针，引用只能调用常成员函数，void fun() const;
普通对象可以调用常成员函数）
类名(参数1,参数2):数据成员1(数据1),数据成员2(数据2){}

A(int _a,double _b):a(_a),b(_b){}

属性构造顺序取决于类中声明顺序，与参数列表顺序无关

组合类

b类的对象为a类的成员
构造过程，先b再a，析构先a再b
若b没有构造函数初始化，要在a构造函数中初始化

函数返回对象可return *this（this取值为对象）。返回对象指针return this（返回指针名）

运算符重载，相当于函数也可有返回值
返回类型 operator运算符（）
返回*this是临时对象，不可改变原对象，返回引用可更改
main里直接操作

继承

class 子类：继承方式 父类｛｝

class B::public A{
};

继承后子类拥有父类的数据成员和函数
protected的成员和函数可在类内访问
private对成员子类不可见，但可以通过父类指针用父类函数访问
公有继承 public全继承，protected进入子类protected内，父类private不可直接访问
保护继承 public和protected都归入子类protected，父类private不可直接访问
私有继承 public和protected归入子类private，父类private不可直接访问
使用private关键字的称封闭类，派生类对其属性操作要调用其函数

子类对象可以给父类赋值，数据截断（父类赋值子类有空值，不可）
父类指针可指子类（只能访问共同的成员）在父类写虚析构函数（virtual ～类名（））来清除父子指针（new申请内存时）

virtual ~A(){}

可用父类建立子类引用

B b;
A &a=b;

多继承 继承多个父类
class 子类：：方式 父类1，方式 父类2｛｝；

class C::public A,public B{
};

多重继承 生成派生类的派生类
使用初始化列表给父类构造函数赋值（父类构造函数有参数）或者增加默认父类构造
父类构造有参数，子类构造要初始化列表父类赋值

虚继承virtual，防止多重继承子类出现多个相同数据类型，构造顺序取决于继承顺序，被虚继承的基类成为虚基类
class 子类：virtual 方式 父类｛｝；

class B::virtual public A{
};

若有菱形继承，2，3继承1，4多继承2，2，则会有重定义错误，1类会构造两次
父类1头声明
宏定义#ifndef 文件名（一般1类名大写）
#define 1类名大写
尾部#endif

#ifndef A
#define A

#endif

多态

相同对象收到不同指令，不同对象收到相同指令产生不同动作
静态多态 编译时就知道函数全部信息，高效，（如函数重载）
动态多态 运行时才决定，灵活（虚函数）
virtual 类型 函数名（）

virtual void function(){}

继承时函数要再写一次，一般虚函数被子类继承，用父类指针指子类对象应用函数。
虚析构后，系统有了选择才能析构子类对象
虚函数不能修饰普通（非成员）函数，静态成员函数，内联函数，构造函数

抽象类，含有纯虚函数的类，不能实例对象
纯虚函数，虚函数声明=0;

virtual void fun()=0;

抽象类的子类也是抽象类（继承了纯虚函数），只有子类的纯虚函数得到声明才可以实例化对象

接口类，只含有纯虚函数的类

运算符重载

±<>+±-等为一元
四则运算，<<（输出格式必须友元重载）为二元，
返回值 operator+（参数1，参数2）可加指针或引用
对于++，前置 返回值 operator++（）
后置 返回值 operator++（int）

int operator++(){}
int operator++(int){}
int operator+(int a,int b){}
friend ostream& operator<<(ostream& os,A &a){}

默认有this指针
成员运算符和友元运算符（友元函数不属于类）也可重载

模板

template函数模板
T max（T a，T b）｛｝

template<class T>
T max(T a,T b){}

或template
void swap（T a，T b）｛｝

template<typename T>
void swap(T a，T b){}

int x=max(100，99);//系统自动选择
char x=max<char>('a','b');//模板函数

自行确定类型
有实例重载时，优先调用非模板函数

swap<int>(x,y);//指定了交换类型

变量（已有类型）作模板参数

template<int size>//已指定类型
void display(){cout<<size;}
display<10>();调用

多个参数

template<typename T,typename C>
void display(){}
display<int,string>(a,str);

类模板

template<class T>    //T在类内可为属性
class xxx{
};

成员函数定义

template<class T>
void xxx<T>::函数名(){}//多参数用逗号隔开<T，S>

实例化对象

xxx<int> yyy()//要声明类型

STL标准模板库

vector<T> v;

T为int，double等，相当于数组可v[x]访问
遍历可以i<v.size()

迭代器，相当于指针输出时*取值

 vector<int>::iterator itor=v.begin();

位置遍历

 itor!=v.end();
 itor++；

链表list，定义及使用同vector，但不能list[1]访问，遍历只能使用迭代器

映射map<key，value> 都可为任意类型
map<int，string> m；m为映射名
pair<int，string> p1（1，“x”）；
m.insert（p1）；将p1插入映射
映射只能使用迭代器遍历，访问可用key索引
迭代器需要itor->first，itor->second访问map的第几个元素

RTTI

运行时类型识别，对于子类独有的成员
#include
typeid（*父对象指针）
子类 子类对象=dynamic_cast<子类>（父对象）

#include<typeinfo>
typeid(*p);
B *b=dynamic_cast<b*>(a);

转换类型必有虚函数，必须是个对象引用，返回子类地址

异常处理

try｛xxx｝（遇到异常语句则终止进入catch
catch（类型）一对多
catch（…）接收所有异常
throw，抛出异常，类型