异常(exception)是指在运行的时刻程序出现反情况。比如:数组下标越界。打开文件夹失败,动态创建内存失败等。程序员一般有自己的异常处理方式。这导致个各种编码方式,。所以很难整合到一个程序中。
异常处理(exception  handing ), 为“响应运行时刻的程序“提供了一个标准语言级的设施。它支持统一的语法和风格,也允许每个程序员进行微调。异常处理                不需要我们在程序中处处显示的测试异常状态。从而可以将测试代码显示的抽取出来,放在指定的 标记的代码块中。因此 异常处理设施大大的 简化了程序的长度和复杂度。
异常处理机制主要构成如下:
1: 程序中异常出现的点。一旦识别出程序的异常,就会抛出异常(throw)。当异常被抛出的时候,程序就会被挂起,知道异常被处理完毕了。c++中,异常的处理有throw表达式来执行。
2:程序中异常被处理的点. 典型的程序的异常抛出和处理位于独立的 函数或者成员函数中。找到异常处理代码一般要展开程序调用栈(progam call stack ).一旦异常被处理完毕,及恢复程序的正常执行。但是不是在出现 异常的地方恢复,而是在处理异常的地方恢复执行过程。在c++中异常的处理用catch表达式来执行。
catch和try字句相关联。一个try块用一个或者多个catch子句将一条或者多条语句组织起来。
系统根据被抛出的异常和catch子句的异常类型的匹配的情况来选择catch子句。
系统把控制传递给catch子句体,其中的语句将顺序执行。完成后后,除非子句体中还抛出异常,否则的话,控制将会被传到程序的当前点上。
posted @ 2008-06-27 14:58 清流琴音 阅读(180) | 评论 (1)编辑 收藏
 
c++的模板提供了一种机制,它能够把函数和类内部的数据和值参数化。这些参数在其他地方不变的代码中用作占位符。以后,这些参数会绑定在实际的数据类型中。可能是内置的数据类型,也可以是用户自定义的 类型。
posted @ 2008-06-27 14:51 清流琴音 阅读(105) | 评论 (0)编辑 收藏
 
在c++ 中,被继承的类称为基类(base class)新类  被称为从基类中派生(derived)来的。我们把它叫做派生类或基类的子类。子类和基类共享公共的接口(common interface--)-----共有操作的公共集.由于共享公共接口,就允许子类和基类在程序内部可以互换使用。而无需考虑对象的类型。从某种意义上说,公共接口接口封装了子类型中与类型相关的细节。类之间的类型和子类型形成了继承和派生层次关系。
在继承的机制下有多个  类的提供者:一个提供基类的实现(可能还提供一些派生类的实现。另外一个或者多个提供者在集成生命周期内提供派生类)。子类的提供者经常要访问(并不总是)基类的实现,为了提供这种能力,同时也为了能够还要防止对积累的一般性的访问,c++中提供了另一种访问级别:保护。在类的保护区域的成员函数和数据成员只提供给它的派生类使用,放在基类的数据成员和数据成员只能被它自己使用,它的派生类也不能使用使用它。

             
posted @ 2008-06-27 10:41 清流琴音 阅读(115) | 评论 (0)编辑 收藏
 

更一般的,c++支持函数重载(funtion  overloding)的机制。c++允许两个或者两个以上的函数具有相同的命名字。限制条件是参数的不同,可以是参数的类型或者数目的不同。根据不同的参数表。编译器就可以区分开调用哪个函数。
重载函数和非重载函数在运行时刻的行为是一样的。只是重载函数在运行的时候,会花费时间来决定到底用哪个函数。如果c++不支持函数重载的话。那么我们就必须为每个函数设置不相同的名字。
如果在类的体外进行成员函数的定义的时候,就必须指出这个成员函数属于哪个类。这个可以通过类的域操作符(calss  scope operator)来实现。
例如:Inarry::
":"冒号操作符被称为域操作符。
当与一个类相连接的时候。它就成为一个域操作符了。
我们可以非正式的把与看作是一个可视的窗口。非全局域的文件在它的这个文件中都是可见的,在一个函数体内定义的对象是局域的,它只在这个函数体内可见。每个类维持一个域。在这个域之外,它的成员是不可见的。类域操作符告诉编译器。域操作符后面的内容是可以在这个域中找到的。
引用:引用是一种没有指针语法的指针。与指针一样,引用提供对对象的间接访问。
类机制还支持特殊析构成员函数(destructor member funtion )每一个类对象在最后一次被使用之后,析构函数就会被自动调用。
我们在析构函数前面加上~线来标识。一般来说,析构函数释放类对象和在构造函数中所获得的资源。

posted @ 2008-06-26 11:56 清流琴音 阅读(152) | 评论 (0)编辑 收藏
 

基于支持对象的类的形式为:
class classname
{
 public////////公有操作集合
private:
//////私有实现代码

}
这里的class,  pulic。和private 是c++的关键字。classname是一个标识符,用来命名类名。以便以后引用该类。
类名代表着一种新型的数据类型,我们可以像定义内置的数据类型一样来定义对象。

例如:
Inarry    inaaay;////定义一个单个类Inarry的对象inaaay;
Inrry *inarry=new Inrry;///////定义一个指向Inrry类的对象的指针。
类的定义包含两个部分:
类头( class head)有关键字class和类名组成。类体(class boday)有花括号括起来。以分号结束。
类头本身也做类的声明。
类体包含成员定义和访问标签。如:public和private。成员定义主要包括:“该类主要实现什么洋的功能,”以及   “代表类抽象所需要的数据”这些操作称为成员函数(member funtion)。或者称为方法(methord)。
程序设计中一个常见的错误是使用先前没有正确被初始化的对象。实际上这是一个十分常见的错误。所以c++为用户定义的类提供了一种自动初始化机制:类的构造函数(calss  constructor)
构造函数是一种特殊的成员函数。专门用于初始化对象,如果构造函数被定义了。那么每个对象在应用的时候,该构造函数就会被自动的应用到该对象上。构造函数由类的提供者来定义。既我们提供类的定义的时候。就必须定义类的构造函数。
为一个类定义一个构造函数是类设计必不可少的一部分。
为了定义一个构造函数。我们只要  给出一个和 类名字相同的函数就可以了。
不能指定构造函数有返回值。可以定义很多的构造函数在一个类中。
尽管她们具有相同的名字,但是只要编译器可以根据参数区分他们就可以了。
更一般的





posted @ 2008-06-24 14:22 清流琴音 阅读(169) | 评论 (0)编辑 收藏
 
在c++中,内存可以是静态分配的——编译器在处理源代码的时候就分配,也可以是动态分配的---程序在 运行的时候调用所需要得库函数进行分配。这两种分配方式各有个的优点。由于静态内存分配是在程序运行之前就分配了内存,所以执行的效率就很高。但是缺乏灵活性。它要求知道程序在之前就知道内存的类型和数目。
例如:
利用静态分配的字符串数组,我们就无法很容易的处理和存贮任意的文本文件。一般来说存贮未知的的数目的元素,需要动态分配内存的灵活性。
例如:以下的定义:
int ival=1024;
指示编译器分配足够的内存来存贮一个整型值。该存储区与名字ival相关联。然后用1024区初始化该存贮区,这些都是在程序之前完成的。
c++支持用指针类型来存放对象的内存地址值。
例如:
为了声明一个存放ival内存地址的的指针类型。我们可以声明如下:
int *print;//////一个指向int类型的指针。
c++预定一个专门取地址的操作符(&),当他应用于一个对象上的时候,返回的是该对象的地址。
因此,为了将ival的地址值赋值给print,我们可以写为:
int*print;
print=&ival;///把ival的地址值赋值给print
为了访问print所指向的内容。我们必须先用解引用(dereference)操作符(*),来先解除的引用。
例如:我们通过print间接的给ival加1;
*print=*print+1;
等价于:
直接对 ival进行操作
ival=ival+1;
在c++中指针主要是用来管理和分配动态分配的内存。
对象的分配可以通过两个不同的版本来实现。
第一个版本用于分配特定类型的单个对象。
int*print=new int 1024);
分配了一个没有名字的int类型的对象,对象的初始化值为1024。然后表达式返回对象在内存中的地址。
接着这个地址用来初始化指针对象print.    对于动态分配的内存。唯一的访问方式是通过指针来访问。
例如:
new的第二个版本,用于分配特定的类型和维数的数组。
int *pia=new int[4];
分配了一个含有4个元素的整型数组。不幸的是我们没有办法给动态分配的数组每个值显示的指定一个初始值。
分配动态数组,一个常令人困惑的问题是,返回值只是一个指针。与分配单一对象的返回值是相同的。
posted @ 2008-06-24 10:11 清流琴音 阅读(558) | 评论 (0)编辑 收藏
 
数组是一组具有相同数据类型的元素的集合。
c++为基本算术数据类型提供了内置的支持。同时他也支持双精度和单精度的数据支持。除此之外c++还支持布尔类型,以及用来存放字符集中单个元素的字符支持。
在内置数据类型和标准库类类型之间的是复合数据类型(compuond type)特别是指针和数组类型。
数组(array)是一个顺序的容器.它包含单一类型的元素。
例如:序列
0 1 1 2 3 5 8 13 21
代表菲波那契序列的前9个数。(只要给出前两个数据,后面的数据就是前两个数据的之和。)
a[8]={0,1,2,3,4,5,6,7}
当a[9]的时候,就会出现一位偏移错误(off-by-one):
通常我们用循环来遍历数组中的元素。
例如:下面的程序初始化了一个数组。前9为分别为0---9
int main()
{
  int ia[10];
  int idex;
 for(idex=0;idex<10;idex++)
{
 ia[idex]=idex;
}
for(idex=9;idex>=0;idex--)
{
 cout<<ia[idex]<<"";
cout<<endl;
}
}
c++虽然对数据类型提供了内置的支持。但是这种支持只是限定于“读写单个数组元素”。c++不支持数组的抽象(abstracion),也不支持对整个数组的操作.我们有时候希望对整个的数组进行操作。例如:把一个数组赋值给另一个数组。对两个数组进行比较。。想知道数组的大小。
例如:给出两个数组,我们不能直接用赋值操作符,把一个数组的值拷贝到另一个数组中去。
比如:
ia1[10], ia2[10]
ia1[10]=ia2[10];/////错误。不能直接把一个数组的值通过赋值运算符赋值给另一个数组。
如果想把一个数组的值赋值给另一个数组我们必须自己编写程序。
for(int idex=0;idex<10;idex++)
{
  ia1[idex]=ia2[idex];

}

而且数组类型并没有自己的意识。它并不知道自己的长度,我们必须另外记录数组的信息。当我们希望把一个数组作为参数传递给一个函数的时候,问题就出现了。在c++中,数组不同于整型类型和浮点类型,它不是c++的一等公民(first——class),它是从c语言中继承而来的,它反映了数据与对其进行操作的算法的分离。这正是过程话程序的特点。
posted @ 2008-06-23 10:28 清流琴音 阅读(212) | 评论 (1)编辑 收藏
 
c++的输入输出功能是由输入输出流(iostream)库提供的,输入输出流库是c++面向对象类层次的一个结构,也是c++库的一部分。
终端的输入也称作是标准的输入(standard input ),与预定义的iostream 对象sin 绑定在一起。
终端输出,也称作是标准输出(standard output ),与预定义的iosream的对象cout 绑定在 一起。
第三那个预定义对象cerr,也称为标准错误。也终端绑定。cerr通常用来给程序用户提示错误的 信息,以警告的信息。
任何想使用iostream库的文件都要包含,相关的头文件。
#include< iostream.h>
输出操作符<<用来把一个值导向cout标准输出或者cerr标准错误上。
例如:
cout<<"\n"; 中的“\n表示换行符(new line),输出换行符的时候,它结束当前的行,并将输出导向下一行。
除了显式的使用"\n"进行换行外,还是可以使用预定义的iostream 操作符endl。进行换行。
操作符在iostream上,进行的是一个操作,而不只是简单的提供一个数据。 
文件的输入和输出:
iostream库也支持的输入和输出。所有能应用在标准当输入和输出的上的操作,也都可以应用在已经被打开的输入和输出文件上。
为了打开一个文件供输入和输出,除了包含iostream外,还必须包含头文件,
#include<fstream>
为了打开一个输出文件,我们必须声明一个ofstream类型的对象。
ofstream outfile("name_of -files");
为了测试是否成功的打开一个文件,我们可以用下面的代码:
if(!outfile)
{
///如果文件不能打开,值为false

}
类似的,如果我们打开一个文件供输入,那么我们必须声明一个ifstream的对象。
ifstream infile("name-of  _files")
if(!infile)

例如:
c++中
从一个文本中1.txt中读内容到2.txt中,
#include<iosrteam>
#include<ftream>
#include<string>
using spacename std;//////注意这里。


posted @ 2008-06-21 16:31 清流琴音 阅读(155) | 评论 (0)编辑 收藏
 

注释是用来帮助程序员来读程序结构的与语言。它是一种礼仪,可以用来说明变量的意义或者用来某一段难懂的代码。注释不会增加可执行代码的长度,在生成可执行代码之前编译器会将注释的部分从程序中去除的。
c++中有两种注释符,一种是注释对(/**/)。与c语言一样,注释的部分放在/**/之间。编译器会将/**/之间的代码当作注释部分,注释的可以放在任何位置。可以含有制表符,空格, 可以跨几行。
第二种注释就是//双斜线。它可以注释单行的内容,注释符右边的内容都会被当作注释的内容而被编译器忽略。

posted @ 2008-06-21 11:14 清流琴音 阅读(138) | 评论 (0)编辑 收藏
 
assert()是c语言标准库提供的一个通用的标准库预处理器宏。在代码中经常用assert()来判断一个必须的前提条件。例如:要打开一个文件,我们必须先知道合格文嘉你的名字,然后在可以打开为了使用assert()必须包含与之对应的头文件
#include < assert.h>
下面是一个简单的例子:
assert(filename!=0);
判断是否文件的名字为0。建兴断言,如果文件的 名字为0,那么断言失败,输出错误的诊断信息,然后中止程序。
assrt.h是c标准库头文件的c名字。c++程序可以通过使用c的库头文件的c名字或者c++的名字来使用它。
这个头文件的c++名字是cassert. c库头文件的c++名字总是以c开头,后面跟的是c名字去掉.h的名字。(因为c++中,头文件的后缀各不相同,所以标准的c++没有指定头文件的后缀).
使用c库头文件名字和使用c++的名字,那么#include 预处理器的效果也是不一样的。
例如:下面的#include指示符;
#include<cassert>
当我们把这个头文件读入我们的文本文件中的时候,头文件中的内容 好似不可见的。因为所有的c++库名字是在std名字空间中定义的。所以我们的文本文件是不可见的。除非我们使用using指示符显示地使其可见。
using  namespace  cassert;
使用c库的头文件就可以直接的在文本文件中使用assert()。而无需使用using指示符了。


posted @ 2008-06-21 11:12 清流琴音 阅读(428) | 评论 (0)编辑 收藏
仅列出标题
共4页: 上一页 1 2 3 4 下一页