为了计算机图形学和数据结构 c++的面向对象

c++的基本精华部分 基本特性 类和类的应用 类的继承和多态以及 c++的i/o文件系统
传统的程序设计方法
程序较小 直接用二进制的机器指令编制程序
规模扩大 出现汇编语言
而后 出现高级程序设计语言
结构化程序设计语言 顺序结构 选择结构 重复（循环）结构 结构化和模块化 而后 函数或过程的实现 与数据结构有关
面向对象的程序设计方法
把一个大问题分解为多个子组 每个子组 就是一个为数据与代码建立的内存区域 并以此来提供模块化的程序设计 这些模块或子组 就被看做样板 （工具）
opp方法 将数据和过程 统一为一个整体 对象 一个具有特定特性 的自完备实体
基本特点 封闭性 继承性 多态性
对象
对客观世界的事物的描述
对象是系统中用来描述客观事物的一个实体 他是构成系统的一个基本单元 一个对象由一组数据（属性）和方法（操作或功能）组成
一个对象的方法和数据可以是这个对象私有
c++ 把对象属性分为 公有的public 保护的protected 和私有的 private
在面向对象的方法中 数据和操作数据的方法是 结合在一起的 这种结合称为封装 对象属性和方法对外部可访问性 称为数据隐藏
1 整体性 2 隐藏性
所谓数据隐藏 就是对象只保留有限的对外接口 而隐藏对象内部的细节
访问一个对象的过程就是 相对像发送一个消息 对象的工作靠消息来激发 对象之间通过消息发生关系 对象归根据消息和他的方法做出不同的响应
类
对一组对象的抽象 实例化 根据这种概念
实质上 类就是一种新的数据类型 object 一个对象被说名为某一个类的变量 也就是某个类的实例
继承
继承是面向对象方法的又一特征举个例子
苹果：食品 苹果继承了食品的一般特性
高层的类通常定义了较为一般化的概念 称为基类 或父类 由它产生的类称为子类或者派生类 派生类从基类继承各种行为和状态 并引入自己的特征 派生类还能将自己的及从基类继承的特征传递下去
多态性
多态性是面向对象程序设计中重要特征 多态性的意义就在于 类的对象能各以不同的方式响应同一消息 即所谓的 同一接口 多种方式 多态性九十的程序发出一个消息后 不同的消息接受者执行不同的响应
// 说到多态，我们不免提到下面几个概念:重载、重写、虚方法、抽象方法以及隐藏方法。这是c#面向对象的多态更容易理解
例子： 定义了一个描述堆栈的类 派生了 三个不同数据类型的类 整型 浮点型 长整型 的堆栈 然后各个对象能以自己的方式响应这同一消息
多态性在程序上通过所谓的联编来实现 按照联编阶段的不同分为静态联编和动态联编 静态联编下的多态性实在编译阶段解决的 这种多态性 也叫做编译时的多态性 动态连篇是在程序的运行阶段解决多态性问题 这种多态性也叫做运行时的多态性
继承机制和多态性相结合 使面向对象方法发挥出更强大的优势

c++对c 语法的扩充
可以说c++是c的超集
变量的定义
c中 int i；
for(i=1;i<10;i++)
c++中 变量的定义可在程序的任意位置 只要遵守先定义后使用的原则
结构体变量的定义
c中必须
struct exs{};
struct exs a;
c++
exs a;
c++的函数原型
在c语言的源程序中如果在函数定义前引用该函数时 应事先勇气函数原型进行说明 但是返回值微整形的函数例外
在c++中 任何一个定义在后调用在前的函数必须先用函数原型进行说明 返回值为整形的函数也不例外
常数说明
const 修饰符定义常量
在c中 说明符const用来说明变量的值在程序中不能被改变 变量的值在初始化时给定 在c++中扩展了
在c++中被说名为const的变量 是作为真正的常数看待
例如
const int a=100；相当于c中的#define a 100；
a在程序中是不能改变的
能被读取
const指针
在c++中 在指针定义语句的类型前加const 就定义了指向常量的指针 百事指向的对象是常量 指针变量可以指向不同的常量 但他所知的内容 （常量本身不能改变）
格式 const 数据类型夫 *指针变量名
const int a=10；
const int *pa；
int b；
下面语句是正确的
pa=&a； pa=&b
但下面的是错的 因为指针pa是指向常量的 而常量是不能修改的
a=20； *pa=b pa=40；
const 说明符还常用在函数的参数中
int sum（const int *a）；
使函数的指针参数的内容不被改变
形式：int *const abc 定义一个整形指针常量abc
在c++中话可以定义指针常量
格式： 数据类型符 *const 指针变量名=初值 ；
这样定义的指针值不能改变 但可以对它所指向的对象的值进行修改 定义时必须初始化
下面定义是正确的
int a，b；
int *const p=&a；
下面是错误的
p=&b；
企图让指针指向另一个地址
但可以改变指针p所指向的数据
*p=20；
c++中第三种指针是定义指向常量的指针常量 其格式 ：
const 数据类型符 *const 指针变量名=初值 ；
这种方法定义的变量 既不能改变指针变量的值，也不能改变指针所指对象的值 定义时必须初始化
设有如下定义
const int a=10；
int b=15;
const int const p=&a;(这a的&前面是不是加0不了解)
则下面的应用是错误的
p=&b; 不能改变指针p的地址
*p=20; 不能改变指针p指向的地址的内容
c++的注释语句
c++的标准I/O操作
在c++中虽然可以使用c中的标准I/O函数 如printf scanf 但c++定义了自己的使用更为方便的标准I/O操作
1数据输出 在c++中 数据的输出是由系统提供的输出流对象cout 完成的 对象cout定义在 iostream.h中 所以程序中使用时 要包含有头文件
#include
这个头文件与c中的stdio.h相对应 但不能相互替代输出语句格式：
cout<<数据1<<数据2···<<数据n；
其中 <<为输出 操作符 在c++中 输出操作定义为插入过程 所以符号 <<又称为插入符 语句的功能实向标准输出设备上输出数据 数据可以是常量变量或表达式
但要注意
在一个语句中多个要输出的数据写在一个cout语句中 是按从右到左的顺序计算各输出项的值 然后 在按从左向右的顺序输出各项的值 在这一点上是与函数printf是一样的
//插入一点规律

#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{
	//*p表示p所指向的地址里面存放的是一个int类型的值 。
	int a,x;
	a = 1;
	x = a;
	printf("%d %d %d %d %d ",a/*a*/,a++/*没有++的a然后c=a输出c*/,++a/*a*/,a+=2/*a*/,a++/*没有++的a然后b=a这个地方已经变为b*/);// 没有a+=2时3 2 3 先从右向左依次计算  然后 5 4 5 5 后来6 5 6 6 1
	cout <<++x<<x <<" "<<x++<<" " <<++x << " " <<x++ << " " <<x++ << " " <<x++ ;//77 5 7 3 2 1  x++就是 先把这个值保存给任何一个其他地址或者直接是常量 然后再让x+=1 而++x就真的直接x+=1并且这个值还是x的地址而且是变量
	return 0;
}

一个cout语句也可以拆很多行 其效果和写成一行是一样的
为实现输出回车换行功能除了可以使用转义字符 “\n”外 还定义了有行结束的流操作符 endl 当需要输出八进制整数时 可以使用格式控制符“ oct”（octonary） 输出十六进制数时可以用格式控制符“hex“（hexadecimal）
数据的输入时使用系统提供的输入流对象cin 完成的 输入操作定义为提取过程 其提取过程 为>>输入语句的格式 ：
cin>>变量名1>>变量名2>>····>>变量名n；
语句的功能 当执行该语句时程序等待用户从键盘输入相应数目的数据 用户以回车结束输入 cin从输入流提取数据并传送给相应的变量 在输入多个数据的情况下 个数据之间可用空格隔开 每输入一个数据按一个回车键也是可以的
输入语句中的变量是整型的 用户可以输入十进制和其他进制数只需要遵守相应的书写格式 如八进制0开头 十六进制0x开头 对于实型变量用户可直接按小数点各式指数格式输入

#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{
	//*p表示p所指向的地址里面存放的是一个int类型的值 。
	double i;
	cin >> i;//12.3e+9
	cout << i;//1.23e+10

	return 0;
}

对于字符型变量 直接输入相应字符 无需引号
作用域区分符
在c语言中讲述了变量作用域的概念我们知道同一个变量名由于他们的作用域不同 他们表示的是不同的对象 全局变量 x进入局部变量x的作用域时 全局变量x是不可见得 是的全局变量不能引用 c++引入了一个作用域区分符 ::指示所要引用的变量是全局变量使得同名的全局变量可以在局部变量的作用域内也能被访问 格式
::变量
例如::a表示访问外部变量a
例子

#include<stdio.h>
#include<iostream>
using namespace std;
int a;
int main()
{
	//*p表示p所指向的地址里面存放的是一个int类型的值 。
	a = 10;
	int a = 20;
	cout<<"a in main  :"<< a<<endl;
	::a *= 20;
	cout << "::a  :" << ::a << endl;
	return 0;
}

函数参数的缺省
在c++中函数的参数可以有缺省值 当调用有缺省参数的函数时 如果没有给出相应的实参 则自动 用相应的缺省参数值作为其实参 函数的缺省参数值是在函数原型中给定的//这还是变量的定义可以在程序的任意位置
例如 ：
int sum（int i=-1,int j=-2）
说明整形函数sum有两个形参i，j 他们都有缺省值 参数i 的缺省值为-1 j的缺省值为-2
函数也可以是部分参数有缺省值 部分参数没有缺省值
引用型变量
c++增加了一个引用型变量 格式
：数据类型 &标识符 =变量
其中符号&是定义引用型变量的标识符 不是取地址运算 符 语句的功能是定义标识符为=右边变量的别名 他们占用同一个物理空间 存储的内容也是同一个 任何对该引用变量的赋值就是对变量的赋值
int &a=x; a=10;
说明a是变量 x的应用变量 执行对a的赋值结果 变量x的值也是10
引用型变量 主要应用于函数传递 其作用相当于c中函数参数的地址传递 但c++的引用传递更方便简洁

例子c++ 的函数引用调用与c函数地址调用的比较

int p;
#include<stdio.h>
#include<iostream>
using namespace std;
int a;
void swap(char* x, char* y)
{
	char ch;
	ch = *x;
	*x = *y;
	*y = ch;
}
void swap_(char &x,char &y)
{
	char ch;
	ch = x;
	x = y;
	y = ch;
}
int main()
{
	int& x = a;
	x = 10;
	printf("%d", a);
	//*p表示p所指向的地址里面存放的是一个int类型的值 。
	
	return 0;
}

int p;
#include<stdio.h>
#include<iostream>
using namespace std;
int a;
void swap(char* x, char* y)
{
	char ch;
	ch = *x;
	*x = *y;
	*y = ch;
}
void swap_(char &x,char &y)
{
	char ch;
	ch = x;
	x = y;
	y = ch;
}
int main()
{
	int& x = a;
	x = 10;
	printf("%d   ", a);
	//*p表示p所指向的地址里面存放的是一个int类型的值 。
	char ch1='a', ch2='b';
	swap_(ch1, ch2);
	cout << ch1 << "   " << ch2 << endl;
	return 0;
}

由于形参x y是定义为引用行所以x就是实参 ch1 的引用y 就是实参ch2 的引用 而任何对形参 x y的操作 实际上就是对实参的操作
内联函数

我们知道 调用函数时喜用要付出一定的开销 用于信息入栈出栈 和参数传递等 特别是对于那些函数体较小单调拥有较为频繁的函数 计算机的开销相对就比较可观 在c语言中 用宏替换 解决这个问题
add （int x,int y）
{
return x+y;
}
用宏替换
#define add((x),(y)) (x)+(y)
这里的宏替换和调用函数不同 他只是在编译源程序时 再有红的地方用（x）+（y）替换add（x，y）从而节省了调用函数所需要的系统开销 当然这势必增加了程序代码的长度
宏替换实质上是文字替换 c++引入了内联函数（inline function）的概念 内联函数在语法上与一般函数完全一样 知识在定义函数时 在函数名前加上说明符 inline 内联函数的一般形式
inline 数据类型 函数名（形参）
{
函数体
}
调用内联函数的方式与一般函数调用也没有什么不同
内联函数与一般函数不同的是 在进行程序的编译时 编译器将内联函数的目标代码做拷贝并将其插入到调用内联函数的地方 这一点很像是宏替换

在这里插入代码片

显然内联函数会增加整个程序的目标代码长度 但减小了系统的开销内联函数适用于函数简单 函数体育局很少 和调用较多的场合
使用inline定义的内联函数 不一定保证他一定当作内联函数处理 这有点像register定义变量 说明 register的变量不一定按Register变量处理
如果内联函数体中有复杂结构控制语句 如switch while 等语句 或含有静态变量等情况 编译器将像处理一般函数那样处理内联函数
动态内存的分配
作为对c语言中malloc和free的替换 c++引入了new 和delete运算符他们的功能是实现内存的动态分配和释放
动态分配new一般有以下三种形式
指针变量 =new 数据类型 ；
指针变量=new 数据类型（初始值）
指针变量=new 数据类型[数量]
int *a,*b;
float *c;
a=new int ;
b=new int(10);
c=float[5];
其中第一个new语句 完成分配一个整型数内存空间并返回一个指向这个空间的指针赋值给指针变量a 第二个new 语句完成分配一个整型数内存空间并初始化内存 将数10存入 返回一个指向这个空间的指针赋值给指针变量b 第三个new 语句 完成分配5各浮点型数内存空间并返回一个指向这个空间的指针赋给指针变量c
释放由new动态分配的内存时 用delete操作 他的一般形式
delete 指针变量 ；
对于数组类型的情况 delete有如下形式
delete [数量]指针变量；
例如释放上述例子
delete a；
delete b；
delete [5]c;
与c的内存动态分配和释放操作（malloc和free ）相比 c++提供的动态分配有以下优点
（1）new 和delete操作自动计算需要分配和释放类型的长度 这不但省去了用sizeof计算长度的步骤 公主要的时避免了内存分配和释放时因长度出错带来的严重后果
（2）new 操作自动返回需分配类型的指针 无需使用强制类型转换
（3）new操作能初始化所分配的类型变量

int p;
#include<stdio.h>
#include<iostream>
using namespace std;
int a;
void swap(char* x, char* y)
{
	char ch;
	ch = *x;
	*x = *y;
	*y = ch;
}
void swap_(char &x,char &y)
{
	char ch;
	ch = x;
	x = y;
	y = ch;
}
int main()
{
	//*p表示p所指向的地址里面存放的是一个int类型的值 。
	float* ptr;
	ptr = new float[2];
	if (!ptr)
	{
		cout << "no scram" << endl;
		return 1;
	}
	ptr[0] = 1.1;
	ptr[1] = 2.2;
	cout << ptr[0] << endl;
	cout << *(ptr + 1) << endl;
	delete[2]ptr;
	return 0;
}