原文地址:
*****C++复习总结******
1.函数模板:实际上是建立一个通用函数,其函数类型和参数类型不具体指定,用一个虚拟的类型来代表,这个通用函数就是函数模板。
#include<iostream>
template<typename T>
Tconst&max(Tconst&a,Tconst&b)
{
returna>b?a:b;
}
intmain(){
intia=16,ib=12;
std::cout<<"a,b中的最大值为:"<<max(ia,ib)<<"\n";
getchar();
}
2.只有类外定义的成员函数规模很小而调用频率较高时,才能将此成员函数指定为内置函数。使用inline关键字。
举例:inline void display();
3.类的数据成员是不能再声明类时初始化的。
4.构造函数:是一种特殊的成员函数,与其他成员函数不同,不需要用户来调用它,而是在建立对象时自动执行。\
构造函数的名字必须与类名同名,而不能由用户任意命名,以便编译系统能识别它并把它作为构造函数处理。
5.参数初始化表实现对数据成员的初始化,这种方法不在函数体内对数据成员初始化,而是在函数首部实现。
举例:Box:Box(int h,int w,int len):height(h),width(w),length(len){}
6.析构函数:也是一个特殊的成员函数,它的作用于构造函数相反,它的名字是类名前面加一个“~”符号,
在C++中“~”是取反运算符,从这点也可以想到:析构函数是与构造函数作用相反的函数。
析构函数的作用并不是删除对象,而是在撤销对象占用内存之前完成一些清理工作。析构函数不能重载。(肯定的,无参怎么重载)
7.this指针:在每一个成员函数中都包括一个特殊的指针,这个指针的名字是固定的,称为this。
它是指向本类对象的指针,它的值是当前被调用的成员函数所在对象的起始地址。
8.对象的常引用:把实参变量的地址传给形参,这样引用名也指向实参变量。
#include<iostream>
usingnamespacestd;
classTime{
public:
Time(int,int,int);
inthour;
intminute;
intsec;
};
Time::Time(inth,intm,ints){
hour=h;
minute=m;
sec=s;
}
voidfun(Time&t){
t.hour=18;
}
intmain(){
Time t1(10,13,56);
fun(t1);
cout<<t1.hour<<endl;
getchar();
return0;
}
9.const的用法,概括来说就是被他修饰的对象,函数,变量或指针程序运行过程中不能别改变。(自己总结的)
10.对象的复制:用一个已有的对象快速的复制出多个完全相同的对象。
举例:Box:box2(box1);
11.静态数据成员:以关键字static开头,如果想在同类的多个对象之间实现数据共享,也不要用全局对象,可以用静态的数据成员。
静态数据成员可以初始化,但只能在类体外进行初始化。成员函数也可以定义为静态的,在类中声明函数的前面加static就成了静态
成员函数。和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一部分。如果要在类外调用共用的静态成员函数,要用
类名和域运算符“::”。静态员函数的作用不是为了对象之间的沟通,而是为了能处理静态数据成员。静态函数没有this指针。既
然它没有指向某一对象,它就无法对一个对象中的非静态成员进默认访问(记在引用数据成员时不指定对象名)。
静态成员函数与非静态成员函数的根本区别是:非静态成员函数有this指针,而静态成员函数没有this指针。由此决定了静态成员函
数不能访问本类中的非静态成员。静态成员函数可以直接引用本类中的静态数据成员,因为静态成员函数同样是属于本类的,可以直
接引用。在C++中,静态成员函数主要用来访问静态数据成员,而不访问非静态成员。
12.友元:在本类中用friend对该函数进行声明此函数就称为本类的友元函数。一个类的有元函数可以访问这个类中的私有成员(破坏
了封装性,但是要考,还是要记住)。Friend函数不仅可以是一般的函数(非成员函数),而且可以是另一类中的成员函数。
一个函数(包括普通函数和成员函数)可以被多个类声明为“朋友”,这样就可以应用多个类中的私有数据。
13.C++允许对类作“提前引用”的声明,即在正式声明一个类之前,先声明一个类名,表示此类将在稍后声明。
14.类模板:模板是类的抽象,类是模板的实例。
#include<iostream>
usingnamespacestd;
template<classnumtype>
classPoint{
private:
numtype x,y;
public:
Point(numtype a,numtype b){
x=a;y=b;
}
numtype addX(Point q){
returnx+q.x;
}
numtype addY(Point q){
returny+q.y;
}
numtype minX(Point q){
returnx-q.x;
}
numtype minY(Point q){
returny-q.y;
}
};
intmain(){
Point<int>p1(2,3);
Point<int>p2(3,4);
Point<double>p3(5.2,3.2);
Point<double>p4(6.4,3.0);
cout<<"第一个点加第二个点后坐标为:"<<p1.addX(p2)<<","<<p1.addY(p2)<<endl;
cout<<"第三个点减第四个点后坐标为:"<<p3.minX(p4)<<","<<p3.minY(p4)<<endl;
getchar();
return0;
}
15.运算符重载:
运算符重载的方法是定义一个重载运算符的函数,在需要执行被重载的运算时,系统就自动调用该函数,实现相应的
运算。也就是说,运算重载是通过定义函数实现的。运算符重载实质上是函数的重载。
#include<iostream>
usingnamespacestd;
//字符串操作类
classString
{
public:
String (){p=NULL;}
String (charstr){p=str;}
friendbooloperator>(String&string1,String&string2);
friendbooloperator<(String&string1,String&string2);
friendbooloperator==(String&string1,String&string2);
voiddisplay();
private:
charp;
};
//输出
voidString::display()
{
cout<<p;
}
//运算符重载
booloperator>(String&string1,String&string2)
{
if(strcmp(string1.p,string2.p)>0)
returntrue;
else
returnfalse;
}
//运算符重载
booloperator<(String&string1,String&string2)
{
if(strcmp(string1.p,string2.p)<0)
returntrue;
else
returnfalse;
}
//运算符重载
booloperator==(String&string1,String&string2)
{
if(strcmp(string1.p,string2.p)==0)
returntrue;
else
returnfalse;
}
//比较
voidcompare(String&string1,String&string2)
{
if(operator>(string1,string2)==1)
{
string1.display();cout<<">";string2.display();
}
elseif(operator<(string1,string2))
{
string1.display();cout<<"<";string2.display();
}
else
{
string1.display();cout<<"=";string2.display();
}
cout<<endl;
}
//时间类
classTime
{
public:
Time(){minute=0;sec=0;}
Time(intm,ints):minute(m),sec(s){}
Timeoperator++();
Timeoperator++(int);
//显示
voiddisplay(){cout<<minute<<":"<<sec<<endl;}
private:
intminute;
intsec;
};
//运算符重载
Time Time::operator++()
{
if(++sec>=60)
{
sec-=60;
++minute;
}
returnthis;
}
//运算符重载
Time Time::operator++(int)
{
Time temp(this);
sec++;
if(sec>=60)
{
sec-=60;
minute++;
}
returntemp;
}
//复杂数类
classComplex
{
public:
Complex(){real=0;imag=0;}
Complex(doubler,doublei):real(r),imag(i){}
Complexoperator+(Complex&c2);
friend ostream&operator<<(ostream&,Complex&);
friend istream&operator>>(istream&,Complex&);
private:
doublereal;
doubleimag;
};
//运算符重载
Complex Complex::operator+(Complex&c2)
{
returnComplex(real+c2.real,imag+c2.imag);
}
//输出流运算符重载
ostream&operator<<(ostream&output,Complex&c)
{
output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
returnoutput;
}
//输入流运算符重载
istream&operator>>(istream&input,Complex&c)
{
cout<<"input real part and imag part of complex number:";
input>>c.real>>c.imag;
returninput;
}
//主函数
intmain()
{
//建立对象
String string1("Hello"),string2("Book"),string3("Compare"),string4("Hello");
Time time(34,0),time2;
Complex c1(2,4),c2(6,10),c3;
Complex c5,c4;
//验证运算符是否重载
cin>>c3>>c4;
cout<<"c3:"<<c3<<endl;
for(inti=0;i<100;i++)
{
++time;
time.display();
}
time2++;
cout<<"time2++:";time2.display();
compare(string1,string2);
compare(string2,string3);
compare(string1,string4);
c3=c1+c2;
return0;
}
16.派生类(通俗点说就是子类):
在声明派生类时,派生类并没有把积累的构造函数继承过来,因此,对继承过来的基类成员初始化的工作也要用派生
类的构造函数承担。所以在设计派生类的构造函数时,不仅要考虑派生类所增加的数据成员的初始化,还应当考虑
基类的数据成员初始化。也就是说,希望在执行派生类的构造函数时,是派生类的数据成员和基类的数据成员同时都
被初始化。解决这个问题的思路是:在执行派生类的构造函数时,调用基类的构造函数。
在执行派生类的析构函数时,系统会自动调用基类函数的析构函数和子对象的析构函数,对基类和子对象进行清理。
调用的顺序与析构函数正好相反,先执行派生类自己的析构函数,对派生类新增加的成员进行清理,然后调用子对象
的析构函数,对子对象进行清理,最后调用基类的析构函数,对基类进行清理。
#include<iostream>
usingnamespacestd;
classStudent{
public:
Student(intn,stringnam,chars){
num=n;
name=nam;
sex=s;
}
~Student(){}
protected:
intnum;
stringname;
charsex;
};
classStudent1:publicStudent{
public:
Student1(intn,stringnam,chars,inta,stringad):Student(n,nam,s){
age=a;
addr=ad;
}
voidshow(){
cout<<"num:"<<num<<endl;
cout<<"name:"<<name<<endl;
cout<<"sex:"<<sex<<endl;
cout<<"age:"<<age<<endl;
cout<<"address:"<<addr<<endl<<endl;
}
~Student1(){}
private:
intage;
stringaddr;
};
intmain(){
Student1 stud1(10010,"Shiyang",'f',19,"115 XingTai");
Student1 stud2(10010,"hahahha",'m',21,"110 Beijing");
stud1.show();
stud2.show();
getchar();
return0;
}
17.多态:多态分为两类:静态多态性和动态多态性,以前学过的函数重载和运算符重载实现的多态性属于静态多态性,在
程序编译时系统就能决定调用哪个函数,因此静态多态性又称为编译时的多态性。静态多态性是通过函数的重载实现的。
动态多态性是在程序运行过程中才动态地确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过虚函数实现的。
18.虚函数:
虚函数的作用是允许在派生类中重新定义与基类同名的的函数,并且可以通过基类指针或引用来访问基类和派生类中的同名函数。
#include<iostream>
#include<complex>
usingnamespacestd;
classBase {
public:
virtualvoidf(int) {
cout<<"Base::f(int)"<<endl;
}
virtualvoidf(double) {
cout<<"Base::f(double)"<<endl;
}
virtualvoidg(inti=20) {
cout<<i<<endl;
}
};
classDerived:publicBase {
public:
voidf( complex<double>) {
cout<<"Derived::f(complex)"<<endl;
}
voidg(inti=10) {
cout<<"Derived::g()"<<i<<endl;
}
};
intmain() {
Base b;
Derived d;
Base*pb=newDerived;
b.f(1.0);
d.f(1.0);
pb->f(1.0);
b.g();
d.g();
pb->g();
delete pb;
return0;
}
19.如果用new运算符建立了临时对象。若基类中有析构函数,并且定义了一个指向该基类的指针变量。在程序用带指针
的参数的delete运算符撤销对象时,会发生一个情况:系统只会执行基类的析构函数,而不执行派生类的析构函数。
声明虚析构函数,即使基类并不需要析构函数,也显示的定义一个函数体为空的虚析构函数,以保证在撤销动态存储空间是能得到
正确的处理。(专业)
20.C++提供虚基类地方法,使得在继承间接共同基类时只保留一份成员。
21.构造函数不能声明为虚函数。这是因为在执行构造函数时类对象还未完成建立过程,当然谈不上函数与类对象的关联。
22.纯虚函数的作用是在基类中为其派生类保留一个函数的名字,以便派生类根据需要对他进行定义。如果在基类中没有保留函数
名字,则无法实现多态性。
23.抽象类:这种不用来定义对象而只作为一种基本类型用作继承的类,称为抽象类。由于由于他常用作基类,通常称
为抽象基类。凡是包含纯虚数的类都是抽象类。因为纯虚函数是不能被调用的,包含纯虚函数的类是无法建立对象的。
抽象类的作用是作为一个类族的共同基类,或者说,为一类族提供一个公共接口。
完
原文链接: https://www.cnblogs.com/wangkangluo1/archive/2011/07/22/2114008.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/29152
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!