C到C++ 快速过度 C 结构体到类
“类”这个概念对C++来说意义非凡,与面向对象密不可分。 从这个概念开始,C++比C复杂的一面越加凸显。
还记得C语言中的结构体么?
struct Point{
double x;
double y;
};
上面的代码是一个“结构体模版”,我们利用它创建了一个叫做Point的类型。
在这之后,我们就可以像声明基本类型的变量一样声明Point类型:
Point ob;
ob叫做结构体Point的一个“实例”。
而当我们 int n; 的时候,会讲n是int类型的一个“变量”。
结构体是一种复合类型,但是它和同样身为复合类型的数组不同:
<!--数组操作技巧-->
char name[20];
我们这样就声明了一个数组,并且每个name[i](0 <=i < 20)都是一个独立的char类型的变量。它们被称为数组的“元素”。
值得一提的是,同一个数组的各个元素所占用的内存空间是连续的。
这使得我们在遍历(检索)整个数组的时候,速度非常的快:
int line[] = {2, 5, 6, 7, 8, 12, -5, -32}; // 1
int len = sizeof(line) / sizeof(int); // 2
for(int i = 0; i < len; i++)
line[i] = -line[i];
上述语句遍历这个数组,并且将每个元素的值都取反。
第 1 个语句说明,数组可以根据你声明时填写的数据自动分配大小,但是一旦分配,数组的大小就定了。
第 2 个语句可以直接确定数组中元素的个数,这样就无需一个个数了。
sizeof是一个操作符,用法类似于函数。当参数是数组名时,将得到整个数组所占内存的字节数;而当参数是类型时,得到的是该类型变量的字节数。
而对于字符串数组,初始化有更方便的方法:
char name[] = "Always Laugh";
这样name就会被自动分配成长度13的数组(别忘了'\0')。
除了之前介绍的使用sizeof操作符取元素个数的方法以外,头文件<string.h>(C++中shi<cstring>)中的strlen函数可以更方便地取字符串长度:
char name[] = "Always Laugh";
int len = strlen(name);
for(int i = 0; i < len; i++)
name[i]++;
这个代码会把name数组的的每个元素在字符表中“后移”一位。
需要注意的是,strlen只能处理char的字符串数组,对int等不适用。
并且它以字符串末尾的'\0'字符为结束标志,因此取到的往往不是数组大小。
<!--类-->
现在介绍C++中的“类”这个概念,它和结构体极其相似。
我们先写一个使用结构体的程序:
#include <iostream>
using namespace std;
struct Point{ // 1 结构体的模版
double x; // 成员
double y;
};
int main()
{
Point p; // 2 结构体的声明
p.x = 3.2; // 3 结构体的使用
p.y = 8.9;
cout << "(" << p.x << "," << p.y << ")" << endl; // 结构体的使用
return 0;
}
结构体的模版和函数的定义性质相同(之后介绍的“类”也同样),只是规定了这个结构体/类的内部结构和工作原理,并不分配内存。
我们在使用结构体对象的时候,总是使用它的成员。“.”这个操作符用来连接结构体的实例和它的成员。
实例的名称可以自由去定义,就像变量名一样,但是相同类型的实例总是拥有的成员确是完全相同的,都和模版中的一致。
即利用相同模版初始化的实例都具有相同的成员。
而当将类引入时,会发生较大的变化:
#include <iostream>
using namespace std;
class Point{
private:
double x;
double y;
public:
setPoint(double m, double n){
x = m; y = n;
}
printPoint(){
cout << "(" << x << "," << y << ")" << endl;
}
};
int main()
{
Point p;
p.setPoint(3.2, 8.9);
p.printPoint();
return 0;
}
这个程序和用结构体的效果是相同的,但是复杂的地方集中在了类的模版定义部分。
出现了很多陌生的东西,private,public,甚至还有函数。
这是因为,对于类而言,不仅变量可以作为成员,函数也可以。
而当你想要在主函数中使用如下语句时:
p.x = 2.2; p.y = 1.1;
你会发现这个不允许的。
原因就在于关键字private(私有的),它将x和y成员保护了起来,使它们在“模版区”之外不能出现。
注意是“不能出现”,而不仅是“不能赋值”。这意味着 cout << p.x; 也是不允许的。
关键字public(公有的)定义的成员可以暴露给外界,正如主函数中的p.setPoint(3.2, 8.9);和p.printPoint();一样。
把x和y设置为私有成员是为了数据的安全性:
int main()
{
Point p;
p.setPoint(3.2, 8.9);
p.printPoint();
return 0;
}
这是刚刚的主函数,我们从中根本看不出p这个类含有哪种或者多少个私有成员,更不知道成员叫做x/y。
它们确实可以在类模版中看到,但是在工程中我们使用的类,大多数是见不到类模版的,他们存放在不同的文件中。
这样,我们只需要知道类的公有成员函数接受哪些变量,起到哪些作用,学会调用即可。至于具体细节,内部逻辑,我们不需要知道。
这就是“封装”,C++的三大特性之一。
正如你看到的,私有成员变量可以在成员函数中直接出现,因为它们处于同一个作用域中(类模版的花括号)。
有私有成员函数吗?当然有。它可以供其他私有成员函数或者公有成员函数去调用。
总之,只有公有成员(可以出现在“模版区”之外)才会和“.”连用。因为一个“实例”的声明和使用都是在外界的。
简而言之:
成员包括私有成员和公有成员。
成员分为成员变量和成员函数。
<!--构造函数-->
class Point{
private:
double x;
double y;
public:
Point(){
}
Point(double m, double n) {
x = m; y = n;
}
setPoint(double m, double n){
x = m; y = n;
}
printPoint(){
cout << "(" << x << "," << y << ")" << endl;
}
};
仍然是那个类,多了两个比较怪异的函数。没错,函数的名称和类名称一样,并且他们不含返回值。
有了它们,我们便可以在主函数中这样子声明p。
int main()
{
Point p(3.2, 8.9);
p.printPoint();
return 0;
}
构造函数是在初始化实例的过程中调用的,这样我们可以在初始化的同时给成员赋值,而setPoint用来改变成员的值。
为什么Point函数声明了两次?还记得函数重载么?我们重载了它。
这样我们既可以在声明实例的时候初始化它,也可以不这么做。
因为构造函数总是会执行的。Point p;和Point p();丝毫没有区别。
<!--些许复杂的示例程序-->
#include <iostream>
#include <cstring>
using namespace std;
struct Friend{
char name[20];
Friend* nest;
Friend(char* pn){
strcpy(name, pn);
nest = NULL;
}
};
struct FriendList{
Friend* head;
Friend* mov;
int number;
bool none;
FriendList(Friend* pri){
head = mov = pri;
number = 1;
none = 0;
}
void ReTop(){
mov = head;
none = 0;
}
void BeFriend(Friend* someone){
Friend* temp = mov->nest;
mov->nest = someone;
someone->nest = temp;
number++;
}
bool Que(Friend *f){
if(none) {
cout << "You got no friends.\n\n";
ReTop();
return 0;
}
if(!mov->nest) none = 1;
char ch;
while(getchar() != '\n') continue;
cout << "Do you wang to make friends with "
<< mov->name << "?" << endl
<< "Y to YES and N to NO" << endl;
cin >> ch;
if(ch == 'Y') {
cout << "You've been friend with " << mov->name << "!\n\n";
BeFriend(f);
ReTop();
return 0;
}else{
mov = mov->nest;
return 1;
}
}
void End()
{
Friend* temp;
while(number--) {
temp = head->nest;
delete(head);
head = temp;
}
}
};
int main()
{
char name[20] = "Always Laugh";
Friend *Me = new Friend(name);
FriendList myFriend(Me);
int T = 4;
while(T--) {
cout << "Enter your name: ";
cin >> name;
Friend* you = new Friend(name);
cout << "Hello " << you->name << "!" << endl;
while(myFriend.Que(you));
}
return 0;
}
这个示例程序对刚接触C++的人来说难度很大,接近一个课设。因为类的内部联系复杂。
并且还用到了动态内存分配(比如new和delete操作符),和链表的内容(这些内容对大家来说是陌生的)。
这是一个交朋友的程序,大家不妨编译运行一下,看看效果,再尽力把代码搞懂(为了避免越界访问,请不要输入得太古怪)。