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 的初探：

 #include <stdio.h>

 struct A
 {
     // defualt to public
     int i;
     // defualt to public
     int getI()
     {
         return i;
     }
 };

 class B  // 以后开发中，只使用这个关键自定义类；
 {
     // defualt to private
     int i;
     // defualt to private
     int getI()
     {
         return i;
     }
 };

 int main()
 {
     A a;
     B b;

     a.i = ;

     printf("a.getI() = %d\n", a.getI());

     b.i = ;

     printf("b.getI() = %d\n", b.getI());

     return ;
 }

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 文件：

 #ifndef _OPERATOR_H_
 #define _OPERATOR_H_

 class Operator
 {
 private:
     char mOp;
     double mP1;
     double mP2;

 public:
     bool setOperator(char op);
     void setParameter(double p1, double p2);
     bool result(double& r);
 };

 #endif

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

2，*.cpp 文件：

 #include "Operator.h"

 bool Operator::setOperator(char op)
 {
     bool ret = false;

     if( (op == '+') || (op == '-') || (op == '*') || (op == '/') )
     {
         ret = true;
         mOp = op;
     }
     else
     {
         mOp = '\0';
     }

     return ret;
 }

 void Operator::setParameter(double p1, double p2)
 {
     mP1 = p1;
     mP2 = p2;
 }

 bool Operator::result(double& r)
 {
     bool ret = true;

     switch( mOp )
     {
         case '/':
             if( (-0.000000001 < mP2) && (mP2 < 0.000000001) )
             {
                 ret = false;
             }
             else
             {
                 r = mP1 / mP2;
             }
             break;
         case '+':
             r = mP1 + mP2;
             break;
         case '*':
             r = mP1 * mP2;
             break;
         case '-':
             r = mP1 - mP2;
             break;
         default:
             ret = false;
             break;
     }

     return ret;
 

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

3，类的使用：

 #include <stdio.h>
 #include "Operator.h"

 int main()
 {
     Operator op;
     double r = ;

     op.setOperator('/');
     op.setParameter(, );

     if( op.result(r) )
     {
         printf("r = %lf\n", r);
     }
     else
     {
         printf("Calculate error!\n");
     }

     return ;
 }

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

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

7，小结：

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

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

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

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

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

1，在头文件中声明类；

1，类的使用方式；

2，在源文件中实现类；

1，类的实现细节；

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