VC++复习笔记

VC++复习笔记

在学习Visual C++ 6.0编程之前,有必要复习一下C++中面向对象的一些基本概念。我们知道,C++与C相比有许多优点,主要体现在封装性(Encapsulation)、继承性(Inheritance)和多态性(Polymorphism)。封装性把数据与操作数据的函数组织在一起,不仅使程序结构更加紧凑,并且提高了类内部数据的安全性;继承性增加了软件的可扩充性及代码重用性;多态性使设计人员在设计程序时可以对问题进行更好的抽象,有利于代码的维护和可重用。Visual C++不仅仅是一个编译器,更是一个全面的应用程序开发环境,读者可以充分利用具有面向对象特性的C++语言开发出专业级的Windows应用程序。熟练掌握本章的内容,将为后续章节的学习打下良好的基矗
2.1 从结构到类
在C语言中,我们可以定义结构体类型,将多个相关的变量包装为一个整体使用。在结构体中的变量,可以是相同、部分相同,或完全不同的数据类型。在C语言中,结构体不能包含函数。在面向对象的程序设计中,对象具有状态(属性)和行为,状态保存在成员变量中,行为通过成员方法(函数)来实现。C语言中的结构体只能描述一个对象的状态,不能描述一个对象的行为。在C++中,对结构体进行了扩展,C++的结构体可以包含函数。
2.1.1结构体的定义
下面我们看看如例2-1所示的程序(EX01.CPP)。
例2-1
#include <iostream.h>
struct point
{
int x;
int y;
};
void main()
{
point pt;
pt.x=0;
pt.y=0;
cout<<pt.x<<endl<<pt.y<<endl;
}
在这段程序中,我们定义了一个结构体point,在这个结构体当中,定义了两个整型的变量,作为一个点的X坐标和Y坐标。在main函数中,定义了一个结构体的变量pt,对pt的两个成员变量进行赋值,然后调用C++的输出流类的对象cout将这个点的坐标输出。
在C++中预定义了三个标准输入输出流对象:cin(标准输入)、cout(标准输出)和cerr(标准错误输出)。cin与输入操作符(>>)一起用于从标准输入读入数据,cout与输出操作符(<<)一起用于输出数据到标准输出上,cerr与输出操作符(<<)一起用于输出错误信息到标准错误上(一般同标准输出)。默认的标准输入通常为键盘,默认的标准输出和标准错误输出通常为显示器。
cincout的使用比C语言中的scanfprintf要简单得多。使用cincout你不需要去考虑输入和输出的数据的类型,cin和cout可以自动根据数据的类型调整输入输出的格式。
对于输出来说,按照例2-1中所示的方式调用就可以了,对于输入来说,我们以如下方式调用即可:
int i;
cin>>i;
 
VC++复习笔记注意:在使用cin和cout对象时,要注意箭头的方向。在输出中我们还使用了endlend of line),表示换行,注意最后一个是字母‘l’,而不是数字1endl相当于C语言的'/n'endl在输出流中插入一个换行,并刷新输出缓冲区。
因为用到了C++的标准输入输出流,所以我们需要包含iostream.h这个头文件,就像我们在C语言中用到了printf和scanf函数时,要包含C的标准输入输出头文件stdio.h。
VC++复习笔记提示:在定义结构体时,一定不要忘了在右花括号处加上一个分号(;)。
我们将结构体point的定义修改一下,结果如例2-2所示:
例2-2
struct point
{
int x;
int y;
void output()
{
cout<<x<<endl<<y<<endl;
}
};
在point这个结构体中加入了一个函数output。我们知道在C语言中,结构体中是不能有函数的,然而在C++中,结构体中是可以有函数的,称为成员函数。这样,在main函数中就可以以如下方式调用:
void main()
{
point pt;
pt.x=0;
pt.y=0;
// cout<<pt.x<<endl<<pt.y<<endl;
pt.output();
}
 
VC++复习笔记注意:在C++中,//......用于注释一行,/*......*/用于注释多行。
2.1.2结构体与类
将上面例2-2所示的point结构体定义中的关键字struct换成class,得到如例2-3所示的定义。
例2-3
class point
{
int x;
int y;
void output()
{
cout<<x<<endl<<y<<endl;
}
};
这就是C++中的类的定义,看起来是不是和结构体的定义很类似?在C++语言中,结构体是用关键字struct声明的类。类和结构体的定义除了使用关键字“class”和“struct”不同之外,更重要的是在成员的访问控制方面有所差异。结构体默认情况下,其成员是公有(public)的;类默认情况下,其成员是私有(private)的。在一个类当中,公有成员是可以在类的外部进行访问的,而私有成员就只能在类的内部进行访问了。例如,现在设计家庭这样一个类,对于家庭的客厅,可以让家庭成员以外的人访问,我们就可以将客厅设置为public。对于卧室,只有家庭成员才能访问,我们可以将其设置为private。
VC++复习笔记提示:在定义类时,同样不要忘了在右花括号处加上一个分号(;)。
如果我们编译例2-4所示的程序(EX02.CPP):
例2-4
#include <iostream.h>
class point
{
int x;
int y;
void output()
{
cout<<x<<endl<<y<<endl;
}
};
void main()
{
point pt;
pt.x=0;
pt.y=0;
pt.output();
}
2.2 C++的特性
下面我们将通过具体的代码演示,给读者讲解C++类的特性。所使用的C++开发工具是微软公司出品的Visual C++ 6.0,操作系统是Windows2000 Server SP4。
VC++复习笔记启动Microsoft Visual C++6.0,如图2.2所示。
VC++复习笔记单击File菜单,选择New,如果2.3所示。
VC++复习笔记在Projects选项卡下,选择Win32 Console Application,如图2.4所示。
VC++复习笔记在右边的Project name:中,输入工程名EX03,单击OK按钮,如图2.5所示。
VC++复习笔记
图2.2 Microsoft Visual C++6.0初始界面
VC++复习笔记
图2.3 选择【File/New】菜单项
VC++复习笔记
图2.4 选择Win32 Console Application工程类型
VC++复习笔记
图2.5 输入工程名
VC++复习笔记在Win32 Console Application-Step 1 of 1中,选择An empty project单选按钮,单击【Finish】按钮,如图2.6所示。
VC++复习笔记出现一个工程信息窗口,单击【OK】按钮,如图2.7所示,这样就生成了一个空的应用程序外壳。
VC++复习笔记 VC++复习笔记
图2.6 选择An empty project选项 图2.7 新工程信息
VC++复习笔记这样的应用程序外壳并不能做什么,甚至不能运行,我们还要为它加上源文件。单击【File】菜单,选择【New】;然后在Files选项卡下,选择C++ Source File,如图2.8所示。
VC++复习笔记
图2.8 为程序增加C++源文件
VC++复习笔记在右边的File文本框中,输入文件名EX03,单击【OK】按钮,如图2.9所示。
VC++复习笔记
图2.9 输入C++源文件名称
并在EX03.cpp文件中输入以下代码:
例2-5
#include <iostream.h>
class point
{
public:
int x;
int y;
void output()
{
cout<<x<<endl<<y<<endl;
}
};
void main()
{
point pt;
pt.output();
}
 
VC++复习笔记说明:在这一章中,我们所有的示例工程都通过上述方式创建。
VC++复习笔记提示:如果你在编译程序时出现了下面的错误,请想想错误的原因,然后参照1.5节给出的问题解决办法,解决下面的错误。
 
--------------------Configuration: EX03 - Win32 Debug--------------------
Compiling...
EX03.CPP
Linking...
LIBCD.lib(wincrt0.obj) : error LNK2001: unresolved external symbol _WinMain@16
Debug/EX03.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.
EX03.exe - 2 error(s), 0 warning(s)
2.2.1类与对象
在这个程序中,我们定义了一个类point,在main函数中我们定义了一个pt对象,它的类型是point这个类。C++语言是面向对象的语言,那么,什么是类?什么是对象呢?
类描述了一类事物,以及事物所应具有的属性,例如:我们可以定义“电脑”这个类,那么作为“电脑”这个类,它应该具有显示器、主板、CPU、内存、硬盘,等等。那么什么是“电脑”的对象呢?例如,我们组装的一台具体的电脑,它的显示器是美格的,主板是华硕的,CPU是Intel的,内存是现代的,硬盘用的是希捷的,也就是“电脑”这个类所定义的属性,在我们购买的这台具体的电脑中,有了具体的值。
这台具体的电脑就是我们“电脑”这个类的一个对象。我们还经常听到“类的实例”,什么是“类的实例”呢?实际上,类的实例和类的对象是一个概念。
对象是可以销毁的。例如,我们购买的这台电脑,它是可以被损毁的。而类是不能被损毁的,我们不能说把电脑毁掉,“电脑”类是一个抽象的概念。
 
 
2.2.2构造函数
按下键盘上的F7功能键编译例2-5的代码,然后按下键盘上的Ctrl+F5执行程序,出现如图2.10所示的运行结果。
从图中可以看到,输出了两个很大的负数。这是因为在构造pt对象时,系统要为它的成员变量xy分配内存空间,而在这个内存空间中的值是一个随机值,在程序中我们没有给这两个变量赋值,因此输出时就看到了如图2.10所示的结果。这当然不是我们所期望的,作为一个点的两个坐标来说,应该有一个合理的值。为此,我们想到定义一个初始化函数,用它来初始化xy坐标。这时程序的代码如例2-6所示,其中加灰显示的部分为新添加的代码。
VC++复习笔记
图2.10 EX03程序的运行结果
例2-6
#include <iostream.h>
class point
{
public:
int x;
int y;
void init()
{
x=0;
y=0;
}
void output()
{
cout<<x<<endl<<y<<endl;
}
};
void main()
{
point pt;
pt.init();
pt.output();
}
然而,对于我们定义的init函数,在编写程序时仍然有可能忘记调用它。那么,能不能在我们定义pt这个对象的同时,就对pt的成员变量进行初始化呢?在C++当中,给我们提供了一个构造函数,可以用来对类中的成员变量进行初始化。
C++规定构造函数的名字和类名相同,没有返回值。我们将init这个函数删去,增加一个构造函数point。这时程序的代码如例2-7所示,其中加灰显示的部分为新添加的代码。
例2-7
#include <iostream.h>
class point
{
public:
int x;
int y;
point() //point类的构造函数
{
x=0;
y=0;
}
void output()
{
cout<<x<<endl<<y<<endl;
}
};
void main()
{
point pt;
pt.output();
}
在程序中,point这个构造函数没有任何返回值。我们在函数内部对xy变量进行了初始化,按F7编译代码,按Ctrl+F5执行程序,可以看到输出结果是两个0。
构造函数的作用是对对象本身做初始化工作,也就是给用户提供初始化类中成员变量的一种方式。可以在构造函数中编写代码,对类中的成员变量进行初始化。在例2-7的程序中,当在main函数中执行“point pt”这条语句时,就会自动调用point这个类的构造函数,从而完成对pt对象内部数据成员x和y的初始化工作。
如果一个类中没有定义任何的构造函数,那么C++编译器在某些情况下会为该类提供一个默认的构造函数,这个默认的构造函数是一个不带参数的构造函数。只要一个类中定义了一个构造函数,不管这个构造函数是否是带参数的构造函数,C++编译器就不再提供默认的构造函数。也就是说,如果为一个类定义了一个带参数的构造函数,还想要无参数的构造函数,则必须自己定义。
VC++复习笔记知识点国内很多介绍C++的图书,对于构造函数的说明,要么是错误的,要么没有真正说清楚构造函数的作用。在网友backer的帮助下,我们参看了ANSI C++的ISO标准,并从汇编的角度试验了几种主流编译器的行为,对于编译器提供默认构造函数的行为得出了下面的结论:
如果一个类中没有定义任何的构造函数,那么编译器只有在以下三种情况,才会提供默认的构造函数:
1.如果类有虚拟成员函数或者虚拟继承父类(即有虚拟基类)时;
2.如果类的基类有构造函数(可以是用户定义的构造函数,或编译器提供的默认构造函数);
3.在类中的所有非静态的对象数据成员,它们所属的类中有构造函数(可以是用户定义的构造函数,或编译器提供的默认构造函数)。
 
 
 
2.2.3析构函数
当一个对象的生命周期结束时,我们应该去释放这个对象所占有的资源,这可以利用析构函数来完成。析构函数的定义格式为:~类名(),如:~point()。
析构函数是“反向”的构造函数。析构函数不允许有返回值,更重要的是析构函数不允许带参数并且一个类中只能有一个析构函数。析构函数的作用正好与构造函数相反,析构函数用于清除类的对象。当一个类的对象超出它的作用范围,对象所在的内存空间被系统回收,或者在程序中用delete删除对象时,析构函数将自动被调用。对一个对象来说,析构函数是最后一个被调用的成员函数。
根据析构函数的这种特点,我们可以在构造函数中初始化对象的某些成员变量,为其分配内存空间(堆内存),在析构函数中释放对象运行期间所申请的资源。
例如,下面这段程序:
class Student
{
private:
char *pName;
public:
Student()
{
pName=new char[20];
}
~Student()
{
delete[] pName;
}
};
在Student类的构造函数中,给字符指针变量pName在堆上分配了20个字符的内存空间,在析构函数中调用delete,释放在堆上分配的内存。如果没有delete[] pName这句代码,当我们定义一个Student的对象,在这个对象生命周期结束时,在它的构造函数中分配的这块堆内存就会丢失,造成内存泄漏。
VC++复习笔记提示:在类中定义成员变量时,不能直接给成员变量赋初值。例如:
class point
{
int x=0;//错误,此处不能给变量x赋值。
int y;
};
2.2.4函数的重载
我们希望在构造pt这个对象的同时,传递x坐标和y坐标的值。可以再定义一个构造函数,如例2-8所示。
例2-8
#include <iostream.h>
class point
{
public:
int x;
int y;
point()
{
x=0;
y=0;
}
point(int a, int b)
{
x=a;
y=b;
}
void output()
{
cout<<x<<endl<<y<<endl;
}
};
void main()
{
point pt(5,5);
pt.output();
}
在这个程序中,有两个构造函数,它们的函数名是一样的,只是参数的类型和个数不一样。这在C语言中是不允许的,而在C++中上述定义是合法的,这就是C++中函数的重载(overload)。当执行main函数中的point pt(5,5)这条语句时,C++编译器将根据参数的类型和参数的个数来确定执行哪一个构造函数,在这里即执行point(int a, int b)这个函数。
重载构成的条件:函数的参数类型、参数个数不同,才能构成函数的重载。分析以下两种情况,是否构成函数的重载。
第一种情况:(1)void output();
(2)int output();
第二种情况:(1)void output(int a,int b=5);
(2)void output(int a);
对于第一种情况,当我们在程序中调用output()函数时,读者认为应该调用的是哪一个函数呢?要注意:只有函数的返回类型不同是不能构成函数的重载的。
对于第二种情况,当我们在程序中调用output(5)时,应该调用的是哪一个函数呢?调用(1)的函数可以吗?当然是可以的,因为(1)的函数第二个参数有一个默认值,因此可以认为调用的是第一个函数;当然也可以是调用(2)的函数。由于调用有歧义,因此这种情况也不能构成函数的重载。在函数重载时,要注意函数带有默认参数的这种情况。
 
 
2.2.5 this指针
我们再看例2-9所示的这段代码(EX04.CPP):
例2-9
#include <iostream.h>
class point
{
public:
int x;
int y;
point()
{
x=0;
y=0;
}
point(int a,int b)
{
x=a;
y=b;
}
void output()
{
cout<<x<<endl<<y<<endl;
}
void input(int x,int y)
{
x=x;
y=y;
}
};
void main()
{
point pt(5,5);
pt.input(10,10);
pt.output();
}
我们在point类中定义了一个input函数。在这个函数中,用参数x和参数y分别给成员变量xy进行了赋值。在main函数中,先调用pt对象的input函数,接收用户输入的坐标值,然后调用output函数输出pt对象的坐标值。
读者可以思考一下这段程序的运行结果,然后编译运行,看看结果和你所思考的结果是一样的吗?
有的读者可能会认为在input(int x, int y)函数中,利用形参x和形参y对point类中的成员变量xy进行了赋值,然而事实是这样吗?因为变量的可见性,point类的成员变量xy在input(int x, int y)这个函数中是不可见的,所以,我们实际上是将形参x的值赋给了形参x,将形参y的值赋给了形参y,根本没有给point类的成员变量xy进行赋值,程序运行的结果当然就是“5,5”了。
如何在input(int x, int y)这个函数中对point类的成员变量xy进行赋值呢?有的读者马上就想到,将input函数的参数名改一下不就可以了吗?比如:将函数改为input(int a, int b),当然,这也是一种解决办法。如果我们不想改变函数的参数名,那么又如何去给point类的成员变量xy进行赋值呢?
在这种情况下,可以利用C++提供的一个特殊的指针——this来完成这个工作。this指针是一个隐含的指针,它是指向对象本身的,代表了对象的地址。一个类所有的对象调用的成员函数都是同一个代码段,那么,成员函数又是怎么识别属于不同对象的数据成员呢?原来,在对象调用pt.input(10,10)时,成员函数除了接收2个实参外,还接收到了pt对象的地址,这个地址被一个隐含的形参this指针所获取,它等同于执行this=&pt。所有对数据成员的访问都隐含地被加上了前缀this->。例如:x=0; 等价于this->x=0。
利用this指针,我们重写input(int x, int y)函数,结果如例2-10所示。
例2-10
#include <iostream.h>
class point
{
public:
int x;
int y;
point()
{
x=0;
y=0;
}
point(int a,int b)
{
x=a;
y=b;
}
void output()
{
cout<<x<<endl<<y<<endl;
}
void input(int x,int y)
{
this->x=x;
this->y=y;
}
};
void main()
{
point pt(5,5);
pt.input(10,10);
pt.output();
}
再编译运行,此时的结果就如预期所料了。
 
 
2.2.6类的继承
1.继承
我们定义一个动物类,对于动物来说,它应该具有吃、睡觉和呼吸的方法。
class animal
{
public:
void eat()
{
cout<<"animal eat"<<endl;
}
void sleep()
{
cout<<"animal sleep"<<endl;
}
void breathe()
{
cout<<"animal breathe"<<endl;
}
};
我们再定义一个鱼类,对于鱼来说,它也应该具有吃、睡觉和呼吸的方法。
class fish
{
public:
void eat()
{
cout<<"fish eat"<<endl;
}
void sleep()
{
cout<<"fish sleep"<<endl;
}
void breathe()
{
cout<<"fish breathe"<<endl;
}
};
如果我们再定义一个绵羊类,对于绵羊来说,它也具有吃、睡觉和呼吸的方法,我们是否又重写一遍代码呢?既然鱼和绵羊都是动物,是否可以让鱼和绵羊继承动物的方法呢?C++中,提供了一种重要的机制,就是继承。类是可以继承的,我们可以基于animal这个类来创建fish类,animal称为基类(Base Class,也称为父类),fish称为派生类(Derived Class,也称为子类)。派生类除了自己的成员变量和成员方法外,还可以继承基类的成员变量和成员方法。
重写animal和fish类,让fish从animal继承,代码如例2-11所示(EX05.CPP)。
例2-11