本篇文章主要讲述C/C++知识点之class和struct区别，希望阅读本篇文章以后大家有所收获，帮助大家对相关内容的理解更加深入。

一、经过不停的改进，结构体 struct 变得原来越不像它在 C 语言中的样子了；

（一）struct 在 C 语言中仅为了定义一个变量的集合，仅此而已，不能定义函数；

（二）struct 在 C++ 中既可以定义访问级别又可以定义成员函数；

二、类的关键字：

（一）struct 在 C 语言中已经有了自己的含义，必须继承兼容；

1．而在 C++ 中有了别的含义，违背了设计 C++ 兼容 C 的初衷；

2．寻找新的关键字来定义类；

（二）在 C++ 中提供了新的关键字 class 用于类定义；

（三）class 和 struct 的用法是完全相同的，但只有一个本质区别，如下；

1．在使用 struct 定义类时，所有成员的默认访问级别为 public；

2．在用 class 定义类时，所有成员的默认访问级别为 private；

三、class 的初探：

1 #include 2
3 struct A
4 {
5     // defualt to public
6     int i;
7     // defualt to public
8     int getI()
9     {
10         return i;
11     }
12 };
13
14 class B  // 以后开发中，只使用这个关键自定义类；
15 {
16     // defualt to private
17     int i;
18     // defualt to private
19     int getI()
20     {
21         return i;
22     }
23 };
24
25 int main()
26 {
27     A a;
28     B b;
29     
30     a.i = 4;
31     
32     printf("a.getI() = %d\n", a.getI());
33     
34     b.i = 4;
35     
36     printf("b.getI() = %d\n", b.getI());
37     
38     return 0;
39 }

四、小实例：

（一）需求：开发一个用于四则运算的类：

1．提供 setOperator 函数设置运算类型；

2．提供 setParameter 函数设置运算参数；

3．提供 result 函数进行运算：

a) 其返回值表示运算的合法性；

b) 通过引用参数返回结果；

（二）客户关心使用、不关心实现、简单易用就好，类的开发者关心类如何实现、内部实现方式；

（三）既然类分为外部接口（使用方式）和内部实现（实现细节）两部分，则最终的源代码上也应该有所体现；

五、类的真正形态：

（一）C++ 中的类支持声明（类的使用方式）和实现（类实现的内部细节）的分离；

（二）使用头文件和源文件的方式来将类的实现和定义分开：

1．*.h 头文件中只有类的声明：

a) 成员变量和成员函数的声明，不包括成员函数体的实现；

2．*.cpp 源文件中完成类的其它实现：

a) 成员函数的具体实现；

六、Operator 类的分析：

（一）*.h 文件：

1 #ifndef _OPERATOR_H_
2 #define _OPERATOR_H_
3
4 class Operator
5 {
6 private:
7     char mOp;
8     double mP1;
9     double mP2;
10     
11 public:
12     bool setOperator(char op);
13     void setParameter(double p1, double p2);
14     bool result(double& r);
15 };
16
17 #endif

a) 仅仅是类的声明而已，表达的也就是用户的需求，仅仅是如何使用这个类；

（二）*.cpp 文件：

1 #include "Operator.h"
2
3 bool Operator::setOperator(char op)
4 {
5     bool ret = false;
6         
7     if( (op == '+') || (op == '-') || (op == '*') || (op == '/') )
8     {
9         ret = true;
10         mOp = op;
11     }
12     else
13     {
14         mOp = '\0';
15     }
16         
17     return ret;
18 }
19
20 void Operator::setParameter(double p1, double p2)
21 {
22     mP1 = p1;
23     mP2 = p2;
24 }
25     
26 bool Operator::result(double& r)
27 {
28     bool ret = true;
29         
30     switch( mOp )
31     {
32         case '/':
33             if( (-0.000000001 < mP2) && (mP2 < 0.000000001) )
34             {
35                 ret = false;
36             }
37             else
38             {
39                 r = mP1 / mP2;
40             }
41             break;
42         case '+':
43             r = mP1 + mP2;
44             break;
45         case '*':
46             r = mP1 * mP2;
47             break;
48         case '-':
49             r = mP1 - mP2;
50             break;
51         default:
52             ret = false;
53             break;
54     }
55         
56     return ret;
57

a) 考虑的是这个类的这些函数功能该如何实现；

（三）类的使用：

1 #include 2 #include "Operator.h"
3
4 int main()
5 {
6     Operator op;
7     double r = 0;
8     
9     op.setOperator('/');
10     op.setParameter(9, 3);
11     
12     if( op.result(r) )
13     {
14         printf("r = %lf\n", r);
15     }
16     else
17     {
18         printf("Calculate error!\n");
19     }
20     
21     return 0;
22 }

a) 编写 main() 函数的函数体时，其实是在使用一个类，但是没有关心它是怎么实现的，仅仅是调用公开的成员函数这些公开的成员函数就是这个 Operator 类的使用方式；

b) 使用类的方式：定义这个类的对象并通过对象来调用共有成员变量或者成员函数；

七、小结：

（一）C++ 引进了新的关键字 class 用于定义类；

1．从此后只使用 class 定义类（一般的）；

2．struct 只用来表示变量的集合（一般的），代表一个结构体；

（二）struct 和 class 的区别在于默认访问级别的不同；

（三）C++ 中的类支持声明和实现的分离，意义在于分两个角度来看待类，一个是声明的角度、一个是实现的角度：

1．在头文件中声明类；

a) 类的使用方式；

2．在源文件中实现类；

b) 类的实现细节；

3．在具体开发中，在 C++ 的头文件里面来做类的声明，在 C++ 的源文件里面来做类的具体实现；

本文由职坐标整理发布，学习更多的相关知识，请关注职坐标IT知识库！