目录
一、从C到C++
C++——面对对象编程
1.什么是对象？
对象由两部分组成 - 描述对象状态或属性的数据（变量）以及描述对象行为或者功能的方法（函数）。
2.为什么要面对对象？
回答这个问题前，先让我们来看一下面向过程编程的流程：
其将大问题分而治之，使解决问题的过程变得清晰；
那么面向对象和面向过程的区别究竟是什么呢？
举例：五子棋游戏
面向过程：1、开始游戏；2、黑子先走；3、绘制画面；4、判断输赢；5、轮到白子；6、绘制画面；7、判断输赢；
8、 返回步骤2；9、输出最后结果。
面向对象：
1、黑白双方，这两方的行为是一模一样的；（两方可以引用一个函数）
2、棋盘系统，负责绘制画面；
3、规则系统，负责判定诸如犯规、输赢；
由上面的例子可以看出面向对象编程具有易复用、易扩展的特点由于面向对象有封装、继承、多态性的特性，可以设 计出低耦合的系统，使系统更加灵活、更加易于维护，而面向过程的编程没有面对对象易复用、易扩展。
通俗点讲用面向过程的方法写出来的程序是一份蛋炒饭，而用面向对象写出来的程序是一份盖浇饭。蛋炒饭是把米饭和 鸡蛋混在一起炒匀。盖浇饭呢，则是把米饭和盖菜分别做好，你如果要一份红烧肉盖饭呢，就给你浇一份红烧肉；如果 要一份青椒土豆盖浇饭，就给浇一份青椒土豆丝。蛋炒饭的好处就是入味均匀，吃起来香。如果恰巧你不爱吃鸡蛋，只 爱吃青菜的话，那么唯一的办法就是全部倒掉，重新做一份青菜炒饭了。盖浇饭就没这么多麻烦，你只需要把上面的盖 拨掉，更换一份盖菜就可以了。盖浇饭的缺点是入味不均，可能没有蛋炒饭那么香。
盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专 业术语就是“可维护性”比较好，“饭”和“菜”的耦合度比较低。蛋炒饭将“蛋”“饭”搅和在一起，想换“蛋”“饭”中任何一种 都很困难，耦合度很高，以至于“可维护性”比较差。
3.C++与C在语法上的一些区别
- 头文件不同
#include <iostream> using namespace std; //再加一个命名空间（防止同名冲突） - 输入输出不同
cin>>a; //输入 cout<<a; //输出 - 字符串，类，函数重载
字符串：
C语言操作字符串——字符数组：char s1[10],s2[10];
char s1[10],s2[10];
scanf("%s\n%s",s1,s2);
printf("%s,%s\n",s1,s2);
C++操作字符串——string类（非基本数据类型）：
先引入头文件#include <string>
string s1,s2;
s1 = “ESTA”;
s2 = “esta” ;
C语言中使用字符串处理函数：
(#include <string.h>)：
连接：strcat(s1,s2);
复制：strcpy(s1,s2);
比较：strcmp(s1,s2);
求长度：strlen(s1);
C++中使用运算符即可完成对字符串的操作:(运算符重载)
复制:s1 = s2;
连接:s1 = s1+s2;
比较:>,<,==,!=…
二.从结构体到类
结构体：
1.如何定义数据？
一般我们定义数据的方法：
单个变量：int a = 10;
数组存放：char b[3] = {‘Y’,‘O’,‘U’};
刚学的字符串类：string c = “China”;
但是这样定义难以体现数据之间的关系；
举例——假设有一道OJ排序题：
{“周一橙","1800000233",0,"计算机科学与技术"}
{“邹易尘","1800000666",1,"物联网工程"}
{“州义诚","1800000213",1,"通信工程"} 要求： 按照学号的顺序给每个学生的信息排序。
用普通的方法定义：
char name[3][10]; //姓名
char id[3][20]; //学号
int sex[3]; //性别
char major[3][100];//专业用结构体定义：
Struct Student {
char name[10];
char id[20];
int sex;
char major[100];
}students[3]; //定义结构体后直接定义结构体变量
访问学生姓名：students[i].name
访问学生学号：
students[i].id
访问学生性别：
students[i].sex
访问学生专业：students[i].major
这样一个学生的性别，学号，专业等属性就关联到了一起 ；
再让我们来看个例子吧：
用结构体模拟一个分数的数据类型,实现分数的四则运算：所有有理数都可以写成 A/B 的分数形式，其中B不为0，A和B都是整 数，为了简化实现，我们只考虑大于0的有理数，且A和B都为正整数；
#include <iostream>
using namespace std;
typedef struct Fraction{
int a,b;
}fraction;//设计一个储存两个整数的结构体；
fraction makefraction(int a, int b){
fraction x;
x.a = a;
x.b = b;
return x;
}//设计一个函数，用于初始化结构体变量：
fraction addfraction(fraction x, fraction y){
return makefraction(x.a*y.b + x.b*y.a,x.b*y.b);
}//实现加法运算的功能；
void printfraction(fraction x){
cout<<x.a<<"/"<<x.b;
}//实现输出结果的功能；
int main()
{
fraction x = makefraction(1,2);
fraction y = makefraction(2,3);
fraction sum;
sum = addfraction(x,y);
printfraction(sum);
return 0;
}
2.关于结构体定义方法的总结
- 先定义结构， 再说明结构变量
struct stu { int num; char name[20]; int age; }; struct stu boy1,boy2; - 在定义结构类型的同时说明结构变量
struct stu { int num; char name[20]; int age; }boy1,boy2; - 直接说明结构变量
typedef struct stu { int num; char name[20]; int age; }student; student boy1,boy2;类：
1.类的定义：
class stu
{
int num;
char name[20];
int age;
void display()
{
cout<<“num:”<<num<<endl;
cout<<“name:”<<name<<endl;
cout<<“age:”<<age<<endl;
}
};
stu stu1,stu2;
2.类的作用：
- 让对象“活”起来 ——成员函数；
- 将概念抽象出来——数据类型，结构体；
- 实现信息隐蔽；
- 子类继承父类；
3.类的声明：
class stu
{
private: //只能被本类中的成员函数引用
int num;
char name[20];
int age;
public: //能被外界调用
void display()
{
cout<<“num:”<<num<<endl;
cout<<“name:”<<name<<endl;
cout<<“age:”<<age<<endl;
}
};
在stu类中private中声明的属性num，name，age只能被本类中的成员函数调用而public中声明的函数或属性能被外界调用；
4.对象的初始化：
- 构造函数
class stu { private: int num; string name; int age; public: //定义构造函数——无需自己调用，创建对象时自动调用 stu(int a=0,string b=“ZYC”,int c=0) { num = a; name = b; age = c; } }stu1(1,”zyc”,1); - 在类中修改和获取私有数据
//在类中定义函数
int SetNum(int n )
{
num = n;
}
int GetNum()
{
return num;
}
5.类的继承
- public:公用继承——父类的公用成员和保护成员仍以相应形式被继承，父类的私有成员被继承，但不能访问（可通过父类的public函数：set和get进行访问）
- protected:保护继承——公用成员以保护成员的形式被继承，私有成员被继承，但不能访问
- private:私有继承——公用成员和保护成员以私有成员的形式被继承，私有成员被继承，但不能访问
class stu { private: int num; string name; int age; public: void print() { cout<<name<<endl; } }; class graduate:public stu //公用继承父类 { private: int score; public: void print_g() { print(); //调用父类的成员函数 cout<<score<<endl; } };
扫一扫
352
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
