您的位置:首页 > 教程资讯 > 皇冠体育的网址 > C++ > C++的新手入门64个答疑

C++的新手入门64个答疑

发布于:2016-05-24 14:03:57   分享到:

基本部分:
1、ctrl+f5 调试不运行,会出现press anykey to continue
f5 调试
2、c++变c,修改Stdafx.h,将#include替换为#include
在主函数源文件中加入using namespace std;

数据类型
3、关于字符型变量。
input:
char a=10;
int b=a+'\a';
output:b=17。
但是字符型的输出不是整数,而是该整数所代表的ASCII码字符。
input:
char a=65;int b=65;
cout<<><>
output:
a 65
4、关于常量,可用预处理命令,宏#define,也可用const定义。
#define LIYAKUN 130
const int liYaKun=130;

基本结构:
5、关于main函数
存在int main(int argc,char *argv),arge表示有多少个参数被传递给主函数,argv[]表示参数以字符串数组的形式来传递。
不存在void main(),main函数存在Int型的返回值。
6、输入输出cin<<,cout>>.
cin需要先按下enter键,然后才处理来自键盘的输入。

运算符:
7、C++中存在>=,<=,为关系运算符。

数组:
8、筛选法。可以通过较小的复杂度筛选出两组混杂的数据。

函数:

9、声明要放在头文件中,可以使被调函数与所有声明保持一致,如果函数接口发生变化,只需要修改唯一的声明。
10、形参在函数调用结束后,形参分配的空间即被释放。
11、值传递是无法实现其功能。
void swap(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
}
12、int _tmain(int argc, _TCHAR* argv[])可以兼容main()。
13、内联函数inline可以减少函数调用时间,因为inline在编译时,在调用处直接用函数体进行替换。减少了普通函数在掉那样时的栈内存的创建和释放的开销。
但是inline不能用循环、If语句,且必须要简洁。
#include "stdafx.h"
using namespace std;
inline int swap(int a,int b);
inline int swap(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
cout<<><>
return 0;
}

指针:
14、指针运算符*,在定义的时候称为指针定义符,此时和指针运算符号的意义完全不同。它的作用是表示所声明的变量的数据类型是一个指针。
int _tmain(int argc, _TCHAR* argv[])
{
int iValue=10;
int *iPtr=&iValue;
cout<<&iPtr<<>
cout<<><>
cout<<*iPtr<<>
}
output:
0071F938
0071F938
10
15、指向函数的指针。实际上是指向存储函数代码的首地址。
定义格式如:数据类型 (* 函数指针名)(形参表);
注意:为了与返回指针的函数进行区别,第一个括号不能省略。
在C++中,赋值的格式如:函数指针名(参数表);
注意:函数指针变量不能进行算数运算,毫无意义。
16、动态内存的分配方式。
堆和栈:1)大小。栈是由系统自动分配的连续的地址空间,1M~2M。堆是通过链表来存储的空闲内存地址,受限于系统的虚拟内存,但远远大于栈的内存。2)栈主要是由局部变量,函参。堆是由程序员自行分配的内存区域。因此,栈的空间由系统自动释放,堆的空间由程序员释放。
动态内存的分配:1)可用链表。也就是堆的方式。属于C++的方式。2)可用malloc等函数分配。是自由存储区的方式。属于C的方式。

比较直观的感觉:当进行数组读写时,动态数组的下标可以用变量来表示。
17、C++动态内存的分配。
格式:new 类型名(初始值);如:pnValue=new int(3);//通过New分配了一个存放int类型的内存空间,并且将这个内存上写初始值3。
注意:如果开辟动态内存,一定要判断是否开辟成功。
如:int _tmain(int argc, _TCHAR* argv[])
{
int *pnValue;
pnValue=new int(3);
if (pnValue==NULL) exit(1);//如果内存开辟失败,指针为NULL
else
cout<<"Success!"<<>
}
18、C++动态内存的赋值。
当申请空间为数组时,为其赋值不要用指针计算,如“pnValue++;”因为存储地址不是连续的,因此当退回时会出现错误。正确的皇冠体育的网址|首页是用过下标或者临时指针来访问动态数组。
下标:int _tmain(int argc, _TCHAR* argv[])
{
int *pnArray=new int[5];
pnArray[0]=1;
pnArray[1]=2;
}
临时指针:int _tmain(int argc, _TCHAR* argv[])
{
int * pnArray=new int[5];
int * pnArrayMove=pnArray;
* pnArrayMove=1;
pnArrayMove++;
* pnArrayMove=2;
}
19、C++初始化动态数组。可用memset函数快速赋值
格式:memset(指针名,初始化值,开辟空间的总字节数)
如:int _tmain(int argc, _TCHAR* argv[])
{
long *plArray=new long[4];
memset(plArray,0,sizeof(long)*5);//sizeof()不能计算动态内存容量
}
20、C++动态内存的释放。
在C中我们用malloce申请,然后用free释放。在C++中我们用new来申请,用delete释放。同样,在释放以后,我们需要把这些指针赋值NULL。
delete a;//a是动态内存变量
delate[] a;//a是动态内存数组
如:int _tmain(int argc, _TCHAR* argv[])
{
long *plArray=new long[10];//申请
meset(plArray,0x00,sizeof(long)*10);//初始化

delete[] plArray;//释放
plArray=NULL;//赋值NULL
}

引用:
21、引用时一个变量或者对象的别名。格式如下:数据类型& 所引用变量或对象名(目标变量或对象)。
如:int _tmain(int argc, _TCHAR* argv[])
{
int nValue;
int& rValue=nValue;
return 0;
}
22、当引用作为函数参数出现时的情况。
在函数被调用时,由于引用函数作为函数参数出现,因此系统在函数体中直接改变实参,这点跟指针的效果一样。这是引用出现的最常见的情况。
如:void swap(int& a,int& b)
{
int temp;
temp=a;
a=b;
b=temp;
}

int _tmain(int argc, _TCHAR* argv[])
{
int nValueA=10;
int nValueB=20;
int& rValueA=nValueA;
int& rValueB=nValueB;
cout<<><><>
swap(rValueA,rValueB);
cout<<><><>
return 0;
}
输出:10,20
20,10
注意:此时,由于函数体改变了引用,。,nValueA=20,nValueB=10。
!! 注意:引用的格式,必须为(类名& 实例名)!空格不能乱加。
!!类名& 函数体(参数),含义是返回一个类的引用。类的实参返回。

共用体:
23、与结构体类型不同的是,共用体的提点1)同一共用体成员共用一个存储区,存储区大小等于最长字节的成员。2)同一时刻,在一个共用体变量中,只有一个成员起作用。

字符串:
24、sizeof()是操作符,用来返回类型的大小,包括\0,strlen()是函数,用来返回字符串的长度,其中不包括\0。
25、cin.getline(数组名称,读取字符数);这个函数读取一行,直至达到换行符,作为字符串的边界。

类:
26、类是C++封装的基本单位,它把数据和函数封装在一起。在定义一个类后,可以声明一个类的变量,即类的对象或者实例。
class 类名?
{

};
命名类的时候加前缀"C"。
27、在定义类的时候,不为类分配存储空间,不能为类中的数据初始化。
28、成员函数。在类中被声明:
class 类名{
访问控制关键字 返回值类型 成员函数名(参数表);
};
访问控制关键字:public/private(default)/protected,因为如果不对其进行设置,系统会默认设置,所以在定义时需要定义它的访问控制字。
如下:
class math(){
public: //习惯性先设置公共部分
void abs();
void add();
void mul();

private:
string number_1;
string number_2;
};
29、成员函数在类外实现。
class Cmath{
void abs();
}

void Cmath::abs(){
cout<<"Success!"<<>
};
30、类的实例,也称对象。当实例为非指针时,访问格式为“实例.类成员”;当实例为指针时,范根格式为“实例指针->类成员”。
如:
math HighMath;
math *pHighMath;
pHighMath=&HighMath;
pHighMath->study();
31、静态数据成员。
当数据在类中声明为private控制型,但在程序过程中需要对它进行修改。此时可以加static来任何类的实例都可以对其数据进行改变。静态数据不属于任何一个实例,只能通过类名来访问。
格式为:int CMath::jingtaishuju=0;
不仅可以在main.cpp中访问,也可以在类实现文件中访问。
32、静态成员函数。
在1)没有实例生成时就需要访问类中的函数信息2)需要所有的类和对象都能访问时,用静态函数。
定义格式:
static 返回值类型 成员函数名(参数表)
访问格式:
类名::成员函数名

构造函数
33、构造函数。构造函数实现在实例被创建时利用特定的值去构造实例,将新建的实例初始化为一个特定状态。
构造函数属于类里面的一个特殊的类,由系统自动调用,定义时无返回值。
格式:
类名();//构造函数名与类名相同
34、带参数的构造函数。带参数的构造函数需要用实参来进行赋值。
!!注意,带参数的构造函数和不带参数的构造函数可以同时存在,相当于构造函数的重载,可8以不带参数赋默认值,也可以带参数,先赋默认值,再赋参数。

所以!最好在每次定义的时候都要写上不带参数的构造函数!

这个地方容易产生很多错误,错例如下:
Cmath xianxingdaishu;
xianxingdaishu.Cmath(1,2,3);
//错误!系统会在第一行语句中默认为,使用默认构造函数,因为构造函数是一直存在的。已经产生了实例以后,这样赋值就是不对的。
如果构造函数要包含参数,就必须在定义的时候给出实参,实参甚至可以不用定义。
改为:
Cmath xianxingdaishu(1,2,3);//此处Cmath不是类名,而是构造函数名。
格式:
类名(初始化参数表);
35、拷贝构造函数。
用一个实例构造另一个实例,使其初始化为与原实例相同的数据,用拷贝构造函数。可以理解为,构造函数为类的一个特殊函数,拷贝构造函数为构造函数的一个特殊例子。拷贝构造函数与构造函数并存。
声明格式:
类名(类名& 实例名)//这里的实例名实际上就是参数名,形参
实现格式:
类名::拷贝构造函数名(类名& 实例参数)//实例参数:形参
36、何时应该声明类头文件?
只在类.cpp和主函数.cpp中声明 类.h。
37、默认拷贝构造函数。
如果不写拷贝构造函数,直接在定义的时候对其进行赋值初始化:
如:
//CMath.h
class CMath{
public:
CMath(string strMathName,string trMathLength,float strMathLevel);//构造函数
//CMath(CMath& MathModel);//拷贝构造函数
void SetMathName();
void SetMathLength();
void SetMathLevel();
void ShowMathName();
void ShowMathLength();
void ShowMathLevel();
private:
string m_strMathName;
string m_strMathLength;
float m_fMathLevel;
};

//CMath.cpp
CMath::CMath(string MathName,string MathLength,float MathLevel){
m_strMathName=MathName;
m_strMathLength=MathLength;
m_fMathLevel=MathLevel;
};
//主函数
#include "stdafx.h"
using namespace std;
#include "CMath.h"
#include "string.h"
int _tmain(int argc, _TCHAR* argv[])
{
CMath MathModel1("FFT","fifty",8);
CMath MathModel2=MathModel1;//调用了默认的拷贝构造函数
MathModel2.ShowMathName();
MathModel2.ShowMathLength();
MathModel2.ShowMathLevel();
}
实际相当于,将所有的非静态变量都赋值给了新定义的实例。
38、默认拷贝构造函数的局限。
1)默认,是完全相同的赋值,实际上很多时候是不必要的。
2)无法实现对动态内存进行拷贝。
39、fatal error LNK1120: 1 个无法解析的外部命令。
因为在头文件已经声明,但是在CPP文件中没有实现。
40、深拷贝。由于存在默认拷贝构造函数的局限性,尤其是在对类中存在动态内存时无法拷贝,深拷贝能完成动态内存的拷贝。
原理,在类中增加深拷贝函数,函数实现中先进行另外一个动态内存申请,然后再赋值。
如:
//CMath.h
class CMath{
public:
CMath(string strMathName,string trMathLength,float strMathLevel);//构造函数
CMath(CMath& MathModel);//拷贝构造函数,深拷贝
void SetMathName();
void SetMathLength();
void SetMathLevel();
void ShowMathName();
void ShowMathLength();
void ShowMathLevel();
private:
string * m_strMathName;//在实现函数中对其进行赋初值,new string
string m_strMathLength;
float m_fMathLevel;
};
//CMath.cpp
CMath::CMath(string MathName,string MathLength,float MathLevel){
m_strMathName=new string;//动态赋初值
*m_strMathName=MathName;
m_strMathLength=MathLength;
m_fMathLevel=MathLevel;
};
CMath::CMath(CMath& MathModel){//建立拷贝构造函数
m_strMathName=new string;//再开动态赋初值
*m_strMathName=*MathModel.m_strMathName;
m_strMathLength=MathModel.m_strMathLength;
m_fMathLevel=MathModel.m_fMathLevel;
};
//主函数
int _tmain(int argc, _TCHAR* argv[])
{
CMath MathModel1("FFT","fifty",8);
CMath MathModel2(MathModel1);//引用已定义的实例
MathModel2.ShowMathName();
MathModel2.ShowMathLength();
MathModel2.ShowMathLevel();
}
41、析构函数。对当前分配的资源进行清理。
声明语法格式:~类名()//virtual ~CMath();//虚析构函数
实现如:CMath::~CMath()
{
delete m_strMathName;
m_strMathName=NULL;
}
注意:析构函数是默认存在的,程序员需要设置对其类中包含的动态变量进行析构。
!!在主程序中不需要调用析构函数,因为系统会在实例的生存期结束以后自动调用类中的析构函数。
!!一旦声明了析构函数,就必须对析构函数进行实现!
42、类的组合。
类的组合其实就是在类的声明里面嵌套其他的类。类的组合主要问题在于初始化,因为要同时对类的内嵌对象进行初始化。
格式:类名::类名(形参表):内嵌对象1(形参表),内嵌对象2(形参表)
{
}
//这个地方还有不清楚的地方。

友元函数和友元类
43、友元就是在需要访问多个类的私有参数时,用到了友元。但是在可以利用关键字friend来修饰。包括友元函数,友元类(类中所有函数都是友元函数)。
声明格式:friend 返回值类型 函数名(参数);
//EleSchStu.h
class EleSchStu{
public:
void SetName(EleSchStu &);
virtual ~EleSchStu();
//设置友元函数来测试名字长度,不一定非要是引用型
friend void CheckNameLength(EleSchStu &);
private:
string strName;
static const int MAX_NAME_LEN;
double score1;
double score2;
double score3;
};
//EleSchStu.cpp
#include "stdafx.h"
using namespace std;
#include "EleSchStu.h"
#include

void EleSchStu::SetName(EleSchStu &xiaoming){
string str;
cout<<"input the name:"<<>
cin>>str;
xiaoming.strName=str;
};

EleSchStu::~EleSchStu(){

};
void CheckNameLength(EleSchStu &xiaoming){
if ((xiaoming.strName.length())>xiaoming.MAX_NAME_LEN)
{
cout<<"输入的名字长度太长了!"<<>
}
};
//主函数
const int EleSchStu::MAX_NAME_LEN=3;
const int JuniorSchStu::MAX_NAME_LEN=3;
int _tmain(int argc, _TCHAR* argv[])
{
EleSchStu xiaoming;
xiaoming.SetName(xiaoming);
CheckNameLength(xiaoming);
return 0;
}

44、include

重载----重载函数和运算符重载
45、重载函数。允许用同一个函数名定义多个函数,简化程序设计。从而使一个函数名就可以完成一系列相关的任务。
重载函数如下一组:?
long abs(long);
double abs(double);
注意!只有是返回类型、参数类型、参数个数、参数顺序上有所不同!不能仅仅是返回值不同。否则不能识别为重载函数。
46、运算符重载。(operator)
对已有的运算符赋予更多的含义。如:使同一个运算符作用于不同类型的数据。(运算符:+,-,*,/,%,new等)
当运算符重载为成员函数时://关键字 operator
格式:函数类型 operator 运算符 (形参表)
{
函数体;
}
为类的友元函数时:
格式: friend 函数体 operator 运算符(形参表)
{
函数体:
}
47、转换运算符的重载。
当用户自定义的数据类型也需要支持数据的转换时,需要用重载转换运算符。而且不能是友元函数。
格式如下:
operator 类型名();//返回类型其实就是类型名,所以不需要制定返回类型。
48、赋值运算符的重载。
关于重载的实例:
需求:写出复数的+、-、*,用类的重载实现,分别用三个友元函数实现运算,能够显示原数据,最终分别用实例来验证三个算法。
//CComplex.h
#include
using namespace std;

//CComplex.h
class CComplex
{
public:
CComplex();//不带参数的构造函数
CComplex(double temp_real,double temp_imag);//含参的构造函数
virtual ~CComplex();
void show();
private:
double real;
double imag;
friend CComplex operator + (CComplex a,CComplex b);
friend CComplex operator - (CComplex a,CComplex b);
friend CComplex operator * (CComplex a,CComplex b);

};
//CComplex.cpp
#include
using namespace std;
#include "stdafx.h"
#include "CComplex.h"

CComplex::CComplex()
{
cout<<"默认构造函数……"<<>
real=0;
imag=0;
}
CComplex::CComplex(double temp_real,double temp_imag)
{
real=temp_real;
imag=temp_imag;
}
CComplex::~CComplex()
{
}

void CComplex::show()
{
cout<<"("<<><><>
}

CComplex operator + (CComplex a,CComplex b)
{
CComplex plus;
plus.real=a.real+b.real;
plus.imag=a.imag+b.imag;
return plus;
}

CComplex operator - (CComplex a,CComplex b)
{
CComplex minus;
minus.real=a.real-b.real;
minus.imag=a.imag-b.imag;
return minus;
}

CComplex operator * (CComplex a,CComplex b)
{
CComplex mult;
mult.real=a.real*b.real-a.imag*b.imag;
mult.imag=a.real*b.imag+a.imag*b.real;
return mult;
}
//重载.cpp
#include "stdafx.h"
#include "CComplex.h"

int _tmain(int argc, _TCHAR* argv[])
{
CComplex p1(1.0,2.0);
CComplex p2(3.0,4.0);
CComplex p3,p4,p5;
p3=p1+p2;
p4=p1-p2;
p5=p1*p2;
p1.show();
p2.show();
cout<<"+:";
p3.show();
cout<<"-:";
p4.show();
cout<<"*:";
p5.show();
return 0;
}

继承和派生:
49、派生类。
派生会接收基类中除了构造函数和析构函数以外的所有成员。也可以改造基类成员,对其进行覆盖和重载,也可以增加新的类成员。
格式:?
class 派生类名:继承方式 基类名1,继承方式 基类名2…
//!继承只有一个冒号!
{
成员声明;
}
// 继承方式的关键字:public/protected/private(default)
50、继承中的访问控制。

为public继承时,基类中保护成员和公有成员在派生类中不变。
为private继承时,基类中保护成员和公有成员在派生类中变为私有成员。(由于会中止类的继续派生,因此Private继承基本没用)
为protected继承时,基类中保护成员和公有成员在派生类中变为保护成员。(在protected继承中,基类中的protected成员在基类的派生中的访问权限还是protected;在private继承中,基类中的protected成员在基类的派生中访问权限是private,因此在下一级的派生中,就无法访问基类的成员!!因此protected继承更加适合多层派生!!)

!!所有的继承均无法访问基类中的私有成员。
!!!Protected 与Public有区别!!protected是保护的,只有他自身或者继承他的类可以用,public是共有的,在静态下所有类都可以通过类名打点调用,不是静态下,可以用类对象点去调用。
!!!???

如例:
#include "stdafx.h"
//Point.h
class CPoint
{
public:
//CPoint();//构造函数
virtual ~CPoint();
void InitPoint(double x,double y);
double GetX();
double GetY();
protected:
double X,Y;
};
#endif
//Linesegment.h
#include "stdafx.h"
#include "CPoint.h"
class CLinesegment:protected CPoint
{
public:
//CLinesegment();
virtual ~CLinesegment();
void InitLinesegment(double x,double y,double length);
double GetX();//可以直接访问基类的保护成员
double GetY();//可以直接访问基类的保护成员
double GetLength();
protected:
//double X,Y;
double Length;
};
//CPoint.cpp
#include "stdafx.h"
#include "CPoint.h"
//#include "Linesegment.h"
CPoint::~CPoint()
{
};
void CPoint::InitPoint(double x,double y)
{
this->X=x;
this->Y=y;
};
double CPoint::GetX()
{
return this->X;
};
double CPoint::GetY()
{
return this->Y;
};
//Linesegment.cpp
#include "stdafx.h"
#include "CPoint.h"
#include "Linesegment.h"
CLinesegment::~CLinesegment()
{
};
void CLinesegment::InitLinesegment(double x,double y,double length)
{
InitPoint(x,y);//调用基类的函数
this->Length=length;
};
double CLinesegment::GetX()//可以直接访问基类的保护成员?????,因为继承类中不存在x,y的成员变量
{
return this->X;
};
double CLinesegment::GetY()//可以直接访问基类的保护成员?????,因为继承类中不存在x,y的成员变量
{
return this->Y;
};
double CLinesegment::GetLength()
{
return this->Length;
};
//主函数
// 保护继承.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include "CPoint.h"
#include "Linesegment.h"

int _tmain(int argc, _TCHAR* argv[])
{
CLinesegment L1;
L1.InitLinesegment(0,0,5);
cout<<"("<<><><><>
return 0;
}
51、派生类的构造函数。
由于派生类不能继承基类的构造函数,因此需要定义构造函数。
声明格式: 构造函数(参数);
实现格式:派生类名::派生类名(参数):继承方式1 基类名1(参数表1),继承方式2 基类名2(参数表2)...,内嵌实例名1(参数表1)//内嵌就是在派生类中又定义的类
{
派生类构造函数函数体;
}
!如果基类中没有自定义的构造函数,就将基类名(参数表)省略。所有都可以省略时,可以用生两侧派生类构造函数的成员初始化列表。
52、派生类的析构函数。
直接析构。
53、派生类成员的标识和访问。
格式:派生类实例名.基类名::成员名;
派生类实例名.基类名::成员函数名(函数表);
::是作用域分辨符,可以用于限定要访问的成员所在的类的名称。
!::不可以嵌套使用,比如:实例A.C1::C2::fun();错误!只能在C2函数中声明fun1(){},再调用fun()。
54、虚基类:解决二义性的问题。
声明格式:class 类名: virtual 继承方式 基类名。
实例:定义一个车的基类,有最大速度、质量成员变量,及一些成员函数;派生出自行车类和汽车类,自行车有高度等成员变量,汽车有座位数等成员变量;从自行车和汽车派生出摩托车类。要求观察析构函数的执行和继承中,把车类设成虚基类和不设为虚基类的区别。
//vehicle.h
#ifndef _vehicle_h_
#define _vehicle_h_
#include "stdafx.h"
class CVehicle
{
public:
CVehicle();
CVehicle(int speed,int weight);
virtual ~CVehicle();
protected:
int Speed;
int Weight;
};
#endif
//vehicle.cpp
#include "stdafx.h"
#include "vehicle.h"

CVehicle::CVehicle()
{
cout<<"CVehicle类的实例的构造函数生成!"<<>
};
CVehicle::CVehicle(int speed,int weight)
{
this->Speed=speed;
this->Weight=weight;
}
CVehicle::~CVehicle()
{
cout<<"CVehicle类的实例的析构函数生成!"<<>
};
//bike.h
#ifndef _bike_H_
#define _bike_H_
#include "stdafx.h"
#include "vehicle.h"

class CBike:virtual public CVehicle
{
public:
CBike();
CBike(int height);
virtual ~CBike();
protected:
int height;
};
#endif
//bike.cpp
#include "stdafx.h"
#include "vehicle.h"
#include "bike.h"

CBike::CBike()
{
cout<<"CBike类的实例的构造函数生成!"<<>
};
CBike::CBike(int height)
{
this->height=height;
}
CBike::~CBike()
{
cout<<"CBike类的实例的析构函数生成!"<<>
};
//car.h
#ifndef _car_H_
#define _car_H_

#include "stdafx.h"
#include "vehicle.h"

class CCar:virtual protected CVehicle
{
public:
CCar();
CCar(int seat);
virtual ~CCar();
protected:
int seat;
};
#endif
//car.cpp
#include "stdafx.h"
#include "vehicle.h"
#include "car.h"

CCar::CCar()
{
cout<<"CCar类的实例的构造函数生成!"<<>
};
CCar::CCar(int seat)
{
this->seat=seat;
};
CCar::~CCar()
{
cout<<"CCar类的实例的析构函数生成!"<<>
};
//motor.h
#ifndef _motor_H_
#define _motor_H_

#include "stdafx.h"
#include "vehicle.h"
#include "bike.h"
#include "car.h"

class CMotor: public CBike,public CCar
{
public:
CMotor();
CMotor(int speed, int weight, int height, int seat, int money):CVehicle(speed,weight),CCar(seat),CBike(height)
{
this->money=money;
};
virtual ~CMotor();
void showMotor();
protected:
int money;
};
#endif
//motor.cpp
#include "stdafx.h"
#include "vehicle.h"
#include "car.h"
#include "bike.h"
#include "motor.h"

CMotor::CMotor()
{
cout<<"构造CMotor类的实例!"<<>
}
CMotor::~CMotor()
{
cout<<"CMotor类的实例的析构函数生成!"<<>
}
void CMotor::showMotor()
{
void showCar();
void showBike();
//showVehicle();
cout<<"speed="<Speed<<>
cout<<"weight="<Weight<<>
cout<<"height="<height<<>
cout<<"seat="<seat<<>
cout<<"money="<money<<>
}
//主函数
// 继承.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include "vehicle.h"
#include "car.h"
#include "bike.h"
#include "motor.h"

int _tmain(int argc, _TCHAR* argv[])
{
int a=200,b=50000,c=1,d=4,e=100000;
CMotor motor(a,b,c,d,e);
motor.showMotor();
return 0;
}
55、多态性
指同一个函数,根据处理的对象不同,所调用的函数实现不同。通过虚函数来实现。
56、虚函数。
当基类定义的一个函数,派生类对函数进行了重载。重载以后,程序无法确定到底是哪个类调用了函数。
当然,我们可以用作用域运算符来确定到底是哪个调用了。但有的情况下,程序会不知道:声明的函数到底调用了基类的对象,还是派生类的对象。因此,程序会默认调用了基类的对象,导致逻辑错误。
!一句话概括:在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类,就调用派生类的函数;如果对象类型是基类,就调用基类的函数。

虚函数定义格式:
virtual 函数返回格式 函数名()
{
};
调用格式():
Class CA
{
public:

virtual float xuhanshu()
{};
}

Class CB:public CA
{
public:
...
virtual float xuhanshu()
{};
}
//mian.cpp

float get_xuhanshu(CA& temp)//注意参数类型
{
return temp.xuhanshu();
}
main()
{
CA test1;
CB test2;
get_xuhanshu(test1);//系统识别调用CA中的实例
get_xuhanshu(test2);//系统识别调用CB中的实例
}

57、纯虚函数和抽象类。
纯虚函数就是在一般的虚函数定义的后面加“=0”,本质上是将指向函数体的指针置零。
抽象类是带有纯虚函数的类。抽象类的作用是为了建立类族的共同接口。抽象类不能实例化,但抽象类的派生类可以实例化。
抽象类中的纯虚函数可以在主函数中实现,然后它的引用可以被任何派生类的实例调用。
如:
class A
{
...
virtual void display()=0;
...
}
class B:A
{
...
virtual void display()
{ cout<<"class B"<<>
...
}
class C:B
{
...
virtual void display()
{ cout<<"class C"<<>
...
}
//main.cpp
void display(A& temp)
{
temp.display();
}

void main()
{
B b;
C c;
display(b);//相当于在主函数中声明了一个函数,只要是A类族的参数都可以调用。
display(c);
}
output:?
class B
class C

例子:抽象类shape,5个派生类,circle,square,rectangle,trapezoid,triangle,用虚函数分别计算几个图形面积,并求它们的和。用基类指针数组,使它的每一个元素指向一个派生类对象。
//shape.h
#ifndef _Shape_H_
#define _Shape_H_
#include "stdafx.h"
class Shape
{
public:
virtual void show(){};
virtual double area()=0;//只有含返回参数的成员函数,才能当作纯虚函数
//主要当作一个接口
};
#endif
//circle.h
#include "stdafx.h"
#include "shape.h"
#include

class circle:public Shape
{
public:
circle(double temp_r)
{
r=temp_r;
};
virtual ~circle(){};
void show()
{
double temp;
temp=area();
cout<<"this is circle! the area is "<<><>
};
double area()
{
double temp;
temp=r*r*3.14;
return temp;
};
protected:
double r;
};
//square.h
#include "stdafx.h"
#include "shape.h"
#include
class square:public Shape
{
public:
square(double l)
{
this->l=l;
};
virtual ~square(){};
double area()
{
double temp;
temp=this->l*this->l;
return temp;
}
void show()
{
double temp=this->area();
cout<<"this is square!,the area is "<<><>
}
protected:
double l;
};

//main.cpp
// 虚函数.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include "shape.h"
#include "circle.h"
#include "square.h"
#include

int _tmain(int argc, _TCHAR* argv[])
{
circle c(5);
square s(5);
Shape *p[2];
p[0]=&c;//虚基类的实例可以指向派生类的引用
p[1]=&s;
p[0]->show();
p[1]->show();
return 0;
}
输入输出体系:
58、流。
流其实形象的比喻了C++中数据传输的过程。
流操作包含了许多类。类名包括:ios,istream,ostream...
59、流格式化输出。
如果需要控制流输出的格式,如果要控制流输出的格式。一种用流格式控制符;另一种是利用流类的相关成员函数进行控制。
1)流控制符:
需要定义头文件;
应用如:
int a=15;
cout<<"十进制"<<><>
cout<<"十六进制"<<><><>
double pi=3.14;
cout<<"指数形式"<<><>
//不需要记住,只需要知道按指数形式输出,8位小数
2)流控制成员函数。具体应用要具体查文档。
60、文件操作。
首先需要定义输入输出文件流对象头文件
声明对象:
ifstream file_in;//建立输入文件流对象
ofstream file_out;//建立输出文件流对象
fstream file_inout;//建立输入输出文件流对象
构造函数:
ifstream::ifstream(const char*,int=ios::in,int=filebuf::openprot);
ofstream::ofstream(congst char*,int=ios::out,int=filebuf::openprot);
fstream::fstream(cont char*,int,int=filebuf::operprot);
调用构造函数如:
ofstream file_out("C:\\a_out.dat",ios::out|ios::binary);//以二进制方式打开输出文件。
61、检查是是否打开文件。关闭文件。
bool fail();//失败返回true,成功返回false。
类中的成员函数close():
void close();
62、关于写文件。
分为读写字符型文件(主要是读写到.txt)和二进制文件(都写到.dat)。
具体应用如下。
// 打开文件.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include
#include
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
//打开文件!
ofstream file_out;//定义打开文件类

file_out.open("C:\\c++.txt",ios::out|ios::app);//打开文件,用于数据输出,从文件中写数据,app是以数据追加方式打开。
if(file_out.fail()) //如果文件打开失败,则显示出错信息。
{
cerr<<"文件 c++.txt 打开失败!"<<>
return 1;
}

//输出到文件!
//利用插入操作符进行输出
file_out<<"wo cao ni ma!"<<>
file_out<<"我草泥马!"<<>

//利用put()进行输出
char a = '!';
file_out.put(a);

//文件的内容输入到内存!
//利用提取操作符
ifstream file_in;//定义打开文件类

file_in.open("C:\\c++.txt",ios::in);//打开文件,用于数据输入,从文件中读数据)
if(file_in.fail()) //如果文件打开失败,则显示出错信息。
{
cerr<<"文件 c++.txt 打开失败!"<<>
return 1;
}

char nRead = 0;
while (!file_in>>nRead)//读取字符,注意,提取的时候是忽略换行和空格字符的
{
cout<
}


while (!file_in.eof())//读取字符,注意,提取的时候是包括换行和空格字符的
//eof()用于判断指针是否已经到文件的末尾了,当返回ture时,已经到达文件的尾部
{
file_in.get(nRead);
cout<<>
}

file_out.close();//关闭文件
file_in.close();

return 0;
}
实例:定义一个结构体,通过键盘输入学生的信息并保存到磁盘stud.dat文件中,并从中读出来显示在屏幕上。
// 二进制文件操作.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include
using namespace std;
#include
#include

struct Student
{
char name[20];
int age;
char No[20];
char sex[20];
};
int _tmain(int argc, _TCHAR* argv[])
{
Student stu[2];
int i;
int j=0;
for(i=0;i<2;i++)
{
cout<<"please insert your name:";
cin>>stu[i].name;
cout<<"please insert your age:";
cin>>stu[i].age;
cout<<"please insert your Number:";
cin>>stu[i].No;
cout<<"please insert your sex:";
cin>>stu[i].sex;
}
ofstream put_in("C:\\c++.dat",ios::out|ios::binary);//打开二进制文件
if (!put_in) //判断是否打开成功
{
cerr<<"C:\\c++.dat can't open it..."<<>
exit(1);
}
for(i=0;i<2;i++)
{
put_in.write((char *) &stu[i],sizeof(stu[i]));//文件写入的时候用的是指针,而不是内容
}
put_in.close();

ifstream put_out("C:\\c++.dat",ios::out|ios::binary);//打开二进制文件
if (!put_out)
{
cerr<<"C:\\c++.dat can't open it..."<<>
exit(1);
}
for(i=0;i<2;i++)
{
put_out.read((char *) &stu[i],sizeof(stu[i]));//成语按函数read()来读二进制文件
}
put_out.close();
for(i=0;i<2;i++) //输出!
{
cout<<"the "<
cout<<><>
cout<<"the "<
cout<<><>
cout<<"the "<
cout<<><>
cout<<"the "<
cout<<><>
}
return 0;
}

63、异常。
try(){throw 类型名;};
catch(类型变量)
{
};
做过选课系统的应该比较熟悉。
直接上实例。
//MyException.h
#include "stdafx.h"
class CMyException
{
public:
CMyException(string msg)
{
err_msg=msg;
};
virtual ~CMyException()
{

};
void show()
{
cerr<<><>
}
protected:
string err_msg;
};
//main.cpp
// C++速成.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "MyException.h"
int _tmain(int argc, _TCHAR* argv[])
{
int type;
cout<<"plese insert the number of exception:1.int 2.float 3.double 4.selfdefine"<<>
cin>>type;
try{
switch(type)
{
case 4:
throw CsMyException("wrong!");//抛出自定义类异常
break;
case 1:
throw 1;//整形
break;
case 2:
throw 1.2f;//float
break;
case 3:
throw 1.23;//doubule
break;
default:
break;
}
}

catch(CMyException a)
{
a.show();
}
catch(int b)
{
cerr<<"error int!";
}
catch(float c)
{
cerr<<"error float!";
}
catch(double d)
{
cerr<<"error double!";
}
return 0;
}
API编程:
64、API:Windows Application Programming Interface.
windows底层->win32 API函数->windows应用程序
句柄:本身为内存中一个占有4个字长的数值,用于标识应用程序中不同对象和相同对象的不同实例。句柄与普通指针的区别在于,指针包含的是引用对象的内存地址,而句柄则是由系统所管理的引用标识,该标识可以被系统重新定位到一个内存地址上。这种间接访问对象的模式增强了系统对引用对象的控制。


标签:

C++

关于我们  加入我们  版权声明  商务合作  友情链接  网站地图  站长统计

脚本大全-脚本语言之家-版权所有 

Copyright (C) 2016 jiaoben.net, All Rights Reserved