面向对象概述与c++输入输出
1
使用<iostream>时，由于C++的标准库中所有标识符都被定义于一个名为std的namespace中，因此其后必须带上语句“using namespace std;”。
2
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{ float a=23.4538769;
cout <<"a="<<a<<endl;
cout <<"a="<< setprecision(4)<<a<<endl;//输出整数+小数的有效位数a=23.45
cout<<"a="<<fixed<<setprecision(4)<<a<<endl;//为了使精度设置的含义体现为小数位数，必须提前把浮点数的输出方式设置为定点方式，即fixed
return 0;
}
3
#include <iostream>
using namespace std; int main()
{ char s[100];
cin>>s;//输入不带空格的字符串数据,如果带空格字符串，需要用到cin.get(s,100);
cout<<s<<endl;//输出字符串数据，可带空格，也可不带空格
return 0;
}
4
面向过程的程序设计方法
以功能为中心，强调功能（过程）抽象。
实现了操作的封装，但数据是公开的，数据与对数据的操作分离，数据缺乏保护。
功能易变，程序维护困难。因为功能往往针对某个程序而设计，这使得程序功能难以复用。
基于功能分解的解题方式与问题空间缺乏对应。图形用户界面很难用过程来描述和实现。
5
引用是一种特殊类型的变量，可以被认为是另一个变量的别名。
引用运算符“&”用来说明一个引用。
数据类型 &引用名 = 已定义的变量名
引用本身没有值和地址值，引用的地址值是它被绑定的变量或者对象的地址值，它的值则是被绑定变量的值。
6 实参与形参的三种结合方式： 值调用、传址调用和引用调用
在形参名前加上引用说明符“&”即将其声明为引用，实参则直接采用一般的变量名。
在函数调用时，形参就成了实参的别名，对引用的操作就等同于直接对主调函数中原变量的操作。
值调用：
单向，无法交换2个变量的值。
#include <iostream>
using namespace std;
void fun (int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{ int a = 1,b = 2;
cout << "Before exchange：a= " << a << "，b= " << b << endl;
fun(a, b);
cout << "After exchange：a= " << a << "，b= " << b << endl;
return 0;
}
运行结果：
Before exchange：a=1，b=2
After exchange：a=1，b=2
传值调用：
传址调用是双向的地址传递，通过指针访问地址间接实现交换两个整形变量的值。
#include <iostream>
using namespace std;
void fun (int *x, int *y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
int main()
{ int a = 1,b = 2;
cout << "Before exchange：a= " << a << "，b= " << b << endl;
fun(&a, &b);
cout << "After exchange：a= " << a << "，b= " << b << endl;
return 0;
}
运行结果：
Before exchange：a=1，b=2
After exchange：a=2，b=1
引用调用：
通过引用（变量的别名）直接实现交换两个整形变量的值。
效果与地址调用相同，但是比传址更方便、直接。
#include <iostream>
using namespace std;
void fun (int &x, int &y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{ int a = 1,b = 2;
cout << "Before exchange：a= " << a << "，b= " << b << endl;
fun(a, b);
cout << "After exchange：a= " << a << "，b= " << b << endl;
return 0;
}
运行结果：
Before exchange：a=1，b=2
After exchange：a=2，b=1
从结构体到类
结构体
C语言的结构体是把相互有关联的数据元素组成一个单独的统一体，从这个角度来说，结构体实现了数据的封装。
结构体成员的访问是公开的，即允许结构体外部（例如main函数或GetAverage函数定义中）访问结构体的成员。
有三种访问方式：
①结构体变量：采用结构体变量名.成员的方式。
②结构体指针：采用结构体指针名->成员的方式。
③结构体数组：采用结构体数组名[下标].成员的方式。
实例
#include <iostream>
using namespace std;
struct computer//计算器结构体
{
int op1,op2;//两个操作数
char ch;//运算符
};
int main()
{
computer a;
cin>>a.op1>>a.ch>>a.op2;
switch(a.ch)
{
case '+':cout<<a.op1+a.op2<<endl;break;
case '-':cout<<a.op1-a.op2<<endl;break;
case '*':cout<<a.op1*a.op2<<endl;break;
case '/':if(a.op2==0)
cout<<"不能被0除"<<endl;
else
cout<<a.op1/a.op2<<endl;
break;
default:cout<<"运算符有错"<<endl;
}
return 0;
}
结构体变量用法
computer a;//定义结构体变量a，C++中省略struct
cin>>a.op1>>a.ch>>a.op2;//结构体成员访问方式：结构体变量名.成员
结构体指针用法
computer a,*p=&a;//定义结构体变量a和结构体指针p，p指向a
cin>>p->op1>>p->ch>>p->op2;//结构体指针访问方式：结构体指针名->成员
结构体变量作函数参数（值调用）
void run(computer b)//函数定义
run(a);//函数调用
结构体变指针作函数参数（地址调用）
void run(computer *pb)//函数定义
run(&a);//函数调用
结构体数组
computer a[100];//定义结构体数组a
for(i=0;i<n;i++)
{cin>>a[i].op1>>a[i].ch>>a[i].op2;}//结构体数组元素访问方式：结构数组名[下标].成员
结构体数组指针
computer a[100],*p=a;//定义结构体数组a和指针p
for(i=0;i<n;i++)
{cin>>p[i].op1>>p[i].ch>>p[i].op2;}//结构体数组指针访问方式：结构指针名[下标].成员
//还可以用(指针名+下标)->成员形式访问，例如：p[i].ch 等价于(p+i)->ch
动态数组
#include <iostream>
using namespace std;
int main()
{
int n,i;
cin>>n;//输入数组大小
int *p =new int[n];//根据n的值动态申请数组
p[0]=1;
p[1]=1;
for(i=2; i<n; i++)
p[i]=p[i-2]+p[i-1];
cout<<p[n-1]<<endl;
delete []p;//释放数组空间
return 0;
}
//C++中new申请空间时直接指定数据类型，因此不需要像C中malloc函数那样再做类型转换。
单链表
#include <iostream>
using namespace std;
struct computer//计算器结构体
{ int op1,op2;//两个操作数
char ch;//运算符
computer *next;//链表对一个指针域成员，指向下一个结点
};
int n;//链表结点个数
computer *creat() //用creat函数创建链表
{ computer *head,*p1,*p2;
n=0;//新建链表
p1=p2=new computer;//用new动态申请结点
cin>>p1->op1>>p1->ch>>p1->op2; //输入一个结点数据
head=NULL;
while(p1->op1!=0)//假设操作数1输入0表示结束
{ n=n+1;
if(n==1) head=p1;
else p2->next=p1;
p2=p1;
p1=new computer; //申请一个结点
cin>>p1->op1>>p1->ch>>p1->op2; //输入一个结点数据
}
p2->next=NULL;
return(head);
}
void run(computer *p) //计算处理
{
if(p!=NULL)
do
{ switch(p->ch)
{
case '+':cout<<p->op1<<"+"<<p->op2<<"="<<p->op1+p->op2<<endl;break;
case '-':cout<<p->op1<<"-"<<p->op2<<"="<<p->op1-p->op2<<endl;break;
case '*':cout<<p->op1<<"*"<<p->op2<<"="<<p->op1*p->op2<<endl;break;
case '/':cout<<p->op1<<"/"<<p->op2;
if(p->op2==0)
cout<<"不能被0除"<<endl;
else
cout<<"="<<p->op1/p->op2<<endl;
break;
default:cout<<p->op1<<p->ch<<p->op2<<"运算符有错"<<endl;
}
p=p->next;
}while(p!=NULL);
}
int main()
{
computer *pt,*p,*p1;
pt=creat();//创建链表
run(pt);//计算链表的全部结点
//释放动态申请的结点。
p=pt;
while(p!=NULL)
{ p1=p->next;
delete p;//动态申请的链表，需要用delete释放
p=p1;
}
return 0;
}
类
类是C++数据封装的基本单元，它把数据和函数封装在一起。
//说明部分(类体)
class <类名>
{
public:
<公有段数据及成员函数>
protected:
<保护段数据及成员函数>
private:
<私有段数据及成员函数>
};
//实现部分
<各成员函数的实现>
关键字public、private、protected 为访问权限控制符，规定成员的访问权限，出现顺序和次数无限制；
公有(public)成员提供了类的接口功能，不仅可以被成员函数访问，而且可以在类外被访问；
私有(private)成员是被类隐藏的数据，只有该类的成员或友元函数才可以访问，通常将数据成员定义为私有成员；
保护(protected)成员具有公有成员或私有成员的特性。
定义成员函数
成员函数的定义及实现在类中完成（内联函数）
为了提高运行时的效率，对于较简单的函数可声明为内联形式。
内联函数体中不要有复杂结构（如循环语句和switch语句）。
在类中声明内联成员函数的方式：
将函数体放在类的声明中。
使用inline关键字。
例2.7中：类外定义的成员函数GetAverage()，如果使用inline描述，则是内联函数。即GetAverage函数类外定义写成如下形式：
inline float CStuScore::GetAverage()
{
return (float)((fScore[0] + fScore[1] + fScore[2])/3.0);
}
成员函数的定义及实现在类外完成
将类体和其成员函数分开定义，是开发大型程序通常采用的方法。
在类中加函数声明，在类体外定义成员函数时须按下述格式：
函数类型 类名::成员函数名(参数表)
{
函数体
}
其中，作用域运算符::是用来标识某个成员函数是属于哪个类的。
成员函数的定义及实现与类在不同的文件中完成
类定义的头文件和类的成员函数定义的文件
例如：stud.h文件中放CStuScore类的声明，stud.cpp中放类外定义的成员函数。详细用法在后续的多文件组织中介绍。
类测试-引入对象
①访问一般对象的成员的语法格式：
对象名.数据成员名
对象名.成员函数名(参数表)
②访问指向对象的指针的成员的语法格式：
对象指针名 -> 数据成员名
对象指针名 -> 成员函数名(参数表)
③访问对象数组元素的成员的语法格式：
对象数组名[下标].数据成员名
对象数组名[下标].成员函数名(参数表)
对象的成员具有不同访问类型：main函数可以访问公有成员，不能访问私有成员。私有数据保密，main函数中（类外）通过公有函数调用来设置私有数据成员的值。
面向对象程序设计
- 以数据为中心，强调数据抽象。
- 数据与操作合而为一，实现了数据的封装，加强了数据的保护（数据更安全）。
- 对象相对稳定，有利于程序维护。因为对象往往具有通用性，使得程序容易重用。
- 基于对象/类的解题方式与问题空间有很好的对应。
类的UML标记图
短式仅用1个含有类名的长方框表示。
长式使用3个方框表示。最上面的框中填入类的名称，中间框中填入属性(C++中称为数据成员)，最下面的框中填入成员函数(操作)。
属性和操作可以根据需要进行细化。
图(a)是最简单的形式，仅给出它们的名字；图 (b)给出属性和成员函数的数据类型；图©是进一步细化，给出数据类型和函数类型。当然还可继续细化，例如函数参数类型及访问权限等。
+、-、#表示成员的可见性，分别对应public、private、protected
