C++中的class和struct区别

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

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

    2，struct 在 C++ 中既能够定义访问级别又能够定义成员函数；

 

 2，类的关键字：

    1，struct 在 C 语言中已经有了本身的含义，必须继承兼容；

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

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

    2，在 C++ 中提供了新的关键字 class 用于类定义；

    3，class 和 struct 的用法是彻底相同的，但只有一个本质区别，以下；

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

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

  

 3，class 的初探：

 1 #include <stdio.h>
 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 }

   

 4，小实例：

    1，需求：开发一个用于四则运算的类：

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

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

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

           1，其返回值表示运算的合法性；

           2，经过引用参数返回结果；

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

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

          

 5，类的真正形态：

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

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

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

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

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

           1，成员函数的具体实现；

          

 6，Operator 类的分析：

    1，*.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

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

   2，*.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

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

   3，类的使用：

 1 #include <stdio.h>
 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 }

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

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

   

 7，小结：

    1，C++ 引进了新的关键字 class 用于定义类；

       1，今后后只使用 class 定义类（通常的）；

       2，struct 只用来表示变量的集合（通常的），表明一个结构体；

    2，struct 和 class 的区别在于默认访问级别的不一样；

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

       1，在头文件中声明类；

           1，类的使用方式；

       2，在源文件中实现类；

           1，类的实现细节；

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