C++语言与c语言基础二

函数

函数格式：类型说明符 函数名（含类型说明的形参表）{

}

函数可以有参数，也可没有参数。可以有返回值return ，也可没有返回值。
函数的调用通过函数名。

递归函数
函数可以直接或间接地调用自身，称为递归调用。
递归：分为分解和回归。将大问题分解为小问题传递下去，解出小问题，把小问题的答案代入，通过回归求出大问题
如：5！=》4! * 5 ，4=》3！*4，3！=》2！*3，2！=》1！2 //分解
1！ 2的问题求出答案，打入上式，求出2！，3！，4！，5！。 //回归

#include 
using namespace std;

unsigned fac(unsigned n){
	unsigned f;		//无符号整数
	if(n == 1)
		f=1;
	else
		f = fac(n-1) * n;
	return f;
}

int main(){
	unsigned n;
	cout<<"Enter a positive integer:");
	cin>>n;
	unsigned y = fac(n);
	count<<n<<"!="<<y<<endl;
	return 0;
}

值传递和引用传递
值传递：传递内容本身
引用传递：传递内容所在的地址
引用传递时：

• 声明一个引用时，必须同时对它进行初始化，使他指向一个已存在的对象
• 一旦一个引用被初始化后，就不能改为指向其他对象
• 引用的初始化：int &ri =i; //只能引用变量，不能是数字；

#include 
using namespace std;

void swap(int &a,int &b){
	int t=a;
	a=b;
	b=t;
}
int main(){
	int x=5,y=10;
	cout<<"x="<<x<<"    y="<<y<<endl;
	return 0;
}

内联函数
内联函数不是在调用时发生控制转移，而是在编译时将函数嵌入在每一个调用处。这样就节省了参数传递、控制转移的开销
格式：inline 类型说明符 函数名（含类型说明的形参表）{

}

函数重载
同名函数要参数数目不同或参数类型不同

面向对象程序设计

类：
每个类都有属性即变量，和方法。
每个类都有一个构造函数，其函数名与类名相同。构造函数是在创建类的对象后自动执行，通常用于初始化数据。
方法的调用：类的方法通过类的对象调用：对象.方法名

复制构造函数
复制构造函数的功能是把初始值对象的每个数据成员的值都复制到新建立的对象中。

#include 
using namespace std;

class Point{
Public:
	Point(int xx=0;int yy=){
		x=xx;
		y=yy;
	}
	Point(Point &p);
	int getX(){
		return x;
	}
	int getY(){
		return y;
	}
	private:
	int x,y;
};	//C语言的类这里加分号

Point::Poiint(Point &p){	//复制构造函数初始化
	x =p.x;
	y=p.y;
	cout<<"Copy:"<<endl;
}

void fun1(Point &p){
	cout<<p.getX()<<endl;
}
Point fun2(){
	Point a(1,2);
	return a;
}

int main(){
	Point a(4,5);
	Point b=a;
	cout<<b.getX()<<endl;
	fun1(b);
	b=fun2();
	cout<<b.getX()<<endl;
	return 0;
}

析构函数
析构函数用来完成对象被删除签订一些清理工作
格式：
~类名（）{}
清除的顺序与构造函数顺序相反。

类的组合

类的组合：一个类调用另一个类，或相互调用。

#include 
using namespace std;

class Point{
	public :
	point(int xx=0,int yy=0){
		x =xx;
		y =yy;
	}
	Point(Point &p);
	int getX(){
		return x;
	}
	int getY(){
		return y;
	}
	private:
	int x,y;
};
Point::Poiint(Point &p){	//复制构造函数初始化
	x =p.x;
	y=p.y;
	cout<<"Copy:"<<endl;
}

class Line{
	public :
	Line(Point xp1,Point xp2);
	Line(Line &l);
	double getLen(){return len;}
	private:
	Point p1,p2;
	double len;
};
Line::Line(Line &l):p1(l.p1),p2(l.p2){	//继承p1,p2
	cout<<copy of line<<endl;
	len = l.len;
}
int main(){
	Point myp1(1,1),myp2(4,5);
	Line line(myp1,myp2);
	Line line2(line);
	cout<<"The length of the line is:";
	cout<<line.getLen()<<endl;
	cout<<"The length of the line2 is:";
	cout<<line2.getLen()<<endl;
	return 0;
}

前向引用声明
当A类调用在后面的B类，则需要前向引用声明；
class B;
class A{

}

结构体和联合体

结构体和类的区别
1.C的结构体和C++结构体的区别
1.1 C的结构体内不允许有函数存在，C++允许有内部成员函数，且允许该函数是虚函数。所以C的结构体是没有构造函数、析构函数、和this指针的。
1.2 C的结构体对内部成员变量的访问权限只能是public，而C++允许public,protected,private三种。
1.3 C语言的结构体是不可以继承的，C++的结构体是可以从其他的结构体或者类继承过来的。
以上都是表面的区别，实际区别就是面向过程和面向对象编程思路的区别：
C的结构体只是把数据变量给包裹起来了，并不涉及算法。
而C++是把数据变量及对这些数据变量的相关算法给封装起来，并且给对这些数据和类不同的访问权限。

C语言中是没有类的概念的，但是C语言可以通过结构体内创建函数指针实现面向对象思想。
结构体与类的区别：
1 C++结构体内部成员变量及成员函数默认的访问级别是public,而c++类的内部成员变量及成员函数的默认访问级别是private。
2 C++结构体的继承默认是public，而c++类的继承默认是private。

公有继承：当类的继承方式为公有继承时，基类的公有成员和保护成员的访问属性在派生类中不变，二基类的私有成员不可直接访问。
私有继承：当类的继承方式为私有继承时，基类的公有成员和保护成员都以私有成员身份出现在派生类中，而基类的私有成员在派生类中不可直接访问。

#include 
#include 
#include 
using namespace std;

struct Student{
	int num;
	string name;
	char sex;
	int age;
};//这里是分号
int main(){
	Strudent stu ={97001,"Lin Lin",'F',19};//没有new创建对象
	cout<<"Num:   "<<stu.num<<endl;
	cout<<"Name:  "<<stu.name<<endl;
	cout<<"Sex:   "<<stu.sex<<endl;
	cout<<"Age :  "<<stu.age<<endl;
	return 0;
}
	

联合体
联合体是一种特殊的类，默认访问控制属性也是公共类型。
联合体的全部数据成员共享同一组内存单元。

联合体的各个对象成员，不能有自定义的工造函数、自定义的西沟函数和重载的复制赋值运算符，不仅联合体的对象成员不能有这些函数，这些对象成员的对象成员也不能有，以此类推
联合体不能继承，因而不支持多态。
联合体可以有名也可无名，无名即无名联合体

#include 
#include 
using namespace std;

class ExamInfo{
	public:
	//三种构造函数，分别用等级，是否通过和百分制来初始化
	ExamInfo(string name,char grade):name(name),mode(GRADE),grade(grade){}
	ExamInfo(string name,bool pass):name(name),mode(PASS),pass(pass){}
	ExamInfo(string name,int percent):name(name),mode(PERCENTAGE),percent(percent){}
	void show()

private:
string name;
enum{
	GRADE,
	PASS,
	PERCENTAGE
}mode;
union{
	char grade;
	bool pass;
	int percent;
};
};

void ExamInfo::show(){
	cout<<name<<": ";
	switch(mode){
		case GEADE:
			cout<<grade;
			break;
		case PASS:
			cout<<(pass?"PASS":"FALL");
			break;
		case PERCENTAGE:
			cout<<percent;
			break;
		}
		cout<<endl;
	}
int main(){
	ExamInfo coursel1("English",'B');
	ExamInfo coursel2("Calculus",true);
	ExamInfo coursel3("C++Programing",85);
	coursel1.show();
	coursel2.show();
	coursel3.show();
	return 0;
}

静态作用域static

静态属性static：上一次运行的结果会保留下来，应用于这次计算
静态方法中只能直接访问静态属性，而非静态属性的访问需要创建实例对象后，通过对象名.属性访问
静态属性和静态方法可以通过类名.属性或类名.方法名

友元函数与友元类

友元函数是在类中用关键字friend修饰的非成员函数，在他的函数体重可以通过对象名访问类的私有和保护成员。
友元类：若A类为B类的友元类，则A类的所有成员函数都是B类的友元函数，都可以访问B类的私有和保护成员。
常对象：
常对象const必须初始化，而且不能被更新
类似常成员函数，长数据成员和常引用。

数组

一维数组，二维数组和多位数组
一维数组格式

char [ ] a,b,c; //第一种方式声明
char a[ ],b[ ],c[ ]; //第二种方式声明
[ ] a = new char[3]; // 数组的创建

或者
char[ ] a =new char[3]; //声明与创建

a[0] =0; //数组初始化赋值
a[1] =1;
a[2] =2;

//一步到位格式：

char [ ] c = {‘a’,‘b’,‘c’,‘d’};

二维数组

int [ ] [ ] m ;
m = new int[2][];
m[0] = new int [3];
m[1] =new int [2];

• 这种方式可以随意控制元素的个数

下面这种方式中同一维度的元素个数必须相同。

int [ ] [ ] a = new int [2] [2];
a[0][0] = 2;
a[0][1] = 4;
a[1][0] = 6;
a[1][1] =8;
或者另一赋值方式：
a ={2,4,6,8};

一步方式：

int [ ] [ ] c ={ {1,2}, {3,4} };

多维数组

int [ ] [ ] [ ] m ;
m = new int [3] [ ] [ ];
m[0] = new int [2] [ ];
m[1] = new int [2][ ];
m[2] =new int [1] [ ];
m[0] [0] = new int [3];
m[0][1] =new int [2];
m[1][0] =new int [2];
m[1][1]= new int [1];
m[2][0] =new int [2];

• 这种方式可以随意控制元素的个数

下面这种方式中同一维度的元素个数必须相同。

int [ ] [ ] [ ] m =new int [3] [2] [1];
m = {0,1,2,3,4,5};
或者另一赋值方式：

一步方式：
int [ ] [ ] [ ] m = { { {0},{1} }, { {2},{3} }, { {4},{5} } };

数组的访问通过下标

指针

指针操作的是地址， 通过地址来对其内容进行运算
指针的声明和指针初始化；

int a,b;
int *pa,*pb=&b;
pa=&a;

指针处理数组元素

#include 
using namespace std;

int main(){
	int a[5] ={1,2,3,4,5};
	for(int i =0;i<10;i++)
		cout<<a[i]<<"  ";	//数组下标方式
	return 0;
}

//使用数组名和指针运算
#include 
using namespace std;

int main(){
	int a[5] ={1,2,3,4,5};
	for(int i =0;i<5;i++)
	cout<<*(a+i)<<"  ";	//使用数组名和指针运算
	return 0;
}
	
//使用指针变量
#include 
using namespace std;

int main(){
	int a[5] ={1,2,3,4,5};
	for(int *p =a;p<(a+5);p++)	//将a的首地址给p，通过地址访问内容
	cout<<*p<<"  ";	
	return 0;
}

指针数组与二维数组
指针数组就是带指针的数组；它通过记录的地址，寻找到各个内存，并访问。
二维数组就在一块连续的内存中，通过下标访问。

用指针作为函数参数，指针对应的是地址，指针做参数可以访问到任何地址。
指针型函数返回内容的地址。
指向函数的指针：
数据类型 *函数名（形参表）{

}
就是返回函数的地址，通过函数的执行返回内容的地址；
数据类型 （*函数指针名）（形参表）{

}

#include 
using namespace std;

void printStuff(float){
cout<<"This is the print stuff function."<<endl;
}
void printMessage(float data){
	cout<<"The data to be listed is "<<data<<endl;
}
void printFloat(float data){
cout<<"The data tobe printed is "<<data<<endl;
}

const float PI =3.141559f;
const float TWO_PI = PI *2.0f;

int man(){
	void (*functionPointer)(float);
	printStuff(PI);
	functionPointer = printStuff;
	functionPointer(PI);
	functionPointer=printMessage;
	functionPointer(TWO_PI);
	functionPointer(13.0);
	functionPointer=printFloat;
	functionPointer(PI);
	printFloat(PI);
	return 0;
}

对象指针
对象指针通过对象初始化，再通过对象指针访问对象成员
int main（）{
Point a(4,5);
Point *p1=&a;
cout return 0;
}

vector 向量
向量：多种数据类型的变量。
格式：
java.util.Vector
Vector<向量元素的数据类型> 变量名
向量方法：百度

深复制和浅复制

浅复制：通过对象初始化另一对象，这两个对象都可调用属性和函数。
浅复制可能出现异常，对象1的运行结果可能会叠加到对象2中。。
深复制：通过对象初始化另一对象，并且在构造函数中，初始化复制构造函数

字符串

查看字符串处理函数：自行百度

面向对象设计

继承
格式：
class 本类：继承方式 基类名1，继承方式 基类名2，,继承方式 基类名3，……
{

}；
例子：
clas Derived:public Base1,Private Base2{
public :
Derived();
~Derived();
};

复制构造函数
Derived::Derived(const Derived &v):Base(v){}

虚基类

虚基类就是共同的基类。

#include 
using namespace std;

class Base0{
	public:
	int var0;
	void fun0(){cout<<"Member of Base0"<<endl;
};

class Base1:virtual public Base0{
	public :
	int var1;
};
class Base2:virtual public Base0{
	public :
	int var2;
}
class Derived:public Base1,public Base2{
public :
	int var;
	void fun(){cout<<"Member of Derived"<<endl;}
};

int main(){
	Derived d;
	d.var0=2;
	d.fun0();
	return 0;
}

运算符重载

#include 
using namespace std;
class Clock{
	public:
	Clock(int hour=0,int minute=0,int second=0);
	void showTime() const;
	Clock& operator++();
	Clock operator++(int);
private:
int hour,minute,second;
};

Clock::Clock(int hour/*=0*/,int minute/*=0*/,int second/*=0*/){
	if(0<=hour&&hour<24&&0<=minute&&minute<60&&0<=second&&second<60){
		this->hour=hour;
		this->minute=minute;
		this->second=second;
	}
	else{
		cout<<"Time error!"<<endl;
	}
	Clock&Clock::operator++(){
		second++;
		if(second>=60){
			second-=60;
			minute++;
			if(minute>=60){
				minute -=60;
				hour=(hour+1)%24;
			}
		}
		return 0;
	}
	Clock Clock::o[erator++(int){
	//注意性形参表中的整型参数
	Clock old =*this;
	++(*this);
	return old;
}
int main(){
	Clock myclock(23,59,59);
	cout<<"First time output: ";
	myclock.showTime();
	cout<<"Show myclock++:   ";
	(myclock++).showTime();
	cout<<Show++myclock:     ";
	(++myclock).showTime();
	return 0;
}

虚函数：没有方法体的函数，其方法体通过实现
纯虚函数：抽象类中的虚函数。
结构体：
struct personal_infor{
char name[size_n];
int age;
char gender;
};
struct personal_infor a,b;
struct personal_infor c;

另一种写法：
typedef struct{
char name[size];
int age;
char gender;
}personal_infor;
personal_infor a,b;
personal_infor c;

异常处理

• 自动检测异常
• 手工抛出异常 throw （人为激发异常）
• 自定义异常