클래스와 객체

클래스는 지정된 객체의 형태로 사용되며, 데이터 표현을위한 데이터 처리 방법을 포함하는 방법. 클래스와 메소드의 클래스 데이터 멤버가 호출됩니다. 기능은 클래스에서 클래스 멤버라고합니다.

첫째, 클래스 정의

실제로 데이터하지만 클래스의 이름, 즉, 그것이 무엇을 포함하여 객체 클래스를 정의하고, 무슨 일이이 주제에 할 수있는 무엇을 의미하는지에 대한 정의를 정의하지 않습니다

그것은 클래스 정의의 이름이 클래스 다음에 키워드 클래스로 시작합니다. 클래스의 본문은 중괄호 한 쌍에 포함되어 있습니다. 클래스 정의 후 세미콜론이나 주장의 목록이 와야합니다.

클래스 상자 
{ 
   공개 :
       더블 길이;    // 상자 길이 
      더블 폭;   // 상자의 폭 
      을 두 번 높이;    // 상자 높이 
};

키워드 공공는 액세스 속성 클래스 멤버를 결정합니다. 클래스 객체 범위에서, 클래스 외부 public 멤버는 액세스 할 수 있습니다. 또한 반원 개인 또는 보호 된 지정할 수 있습니다

둘째, C의 정의 ++ 객체

객체는 클래스에 따라 만들어집니다. 같은 변수의 기본 유형을 선언 Object 클래스 선언,

BOX1 상자;           // BOX1를 선언, 상자 입력 
상자 BOX2을;           //이 BOX2를 선언, 입력 상자

BOX1 및 BOX2 객체는 자신의 데이터 멤버가 있습니다.

데이터 멤버에 셋째, 접근

에 액세스하려면 직접 멤버 액세스 연산자 (.)

사용법 #include <iostream> 은 Using 네임 스페이스 STD; 클래스 상자 
{ 공개 :
       더블 길이;    // 길이 더블 폭;   // 폭 을 두 번 높이;    // 높이 }; INT 주 () 
{ 
   상자 BOX1;         // BOX1를 선언, 박스 타입 
   BOX2 박스;         // BOX2 형식 상자 선언 더블 부피 = 0.0 ;      // 볼륨 기억 // 상세한 박스 1. 
   Box1.height = 5.0
 
 
 

   
      
      

 

   
 
    ;
   Box1.length = 6.0 ; 
   Box1.breadth = 7.0 ; 
 
   // 박스 2 상세 
   Box2.height = 10.0 ; 
   Box2.length = 12.0 ; 
   Box2.breadth = 13.0 ; 
 
   // 박스 1 부피 
   용적 = Box1.height * BOX1. * 길이 Box1.breadth; 
   COUT << " BOX1 부피 : " << 볼륨 << ENDL; 
 
   // 박스 2 부피 
   용적 = Box2.height Box2.length * Box2.breadth; 
   COUT << " BOX2 량 : " << 볼륨 << ENDL;
   반환  0 ; 
}

결과 :

BOX1 볼륨 : 210 
BOX2의 볼륨 : 1560

민간 및 보호 위원의 구성원은 직접 멤버 액세스 연산자를 사용할 수 없습니다 (.) 직접 액세스 할 수 있도록

넷째, 클래스 객체는 상세

类成员函数	类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
类访问修饰符	类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
构造函数 & 析构函数	类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
C++ 拷贝构造函数	拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
C++ 友元函数	友元函数可以访问类的 private 和 protected 成员。
C++ 内联函数	通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
C++ 中的 this 指针	每个对象都有一个特殊的指针 this，它指向对象本身。
C++ 中指向类的指针	指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
C++ 类的静态成员	类的数据成员和函数成员都可以被声明为静态的。

그는 추가 :

1.이 포인터 알

클래스 외부 2, 사실, 또한 클래스 내부 포인터의 개인 회원에 액세스 할 수 있습니다

#include <iostream>
using namespace std;

class a    // 定义了类a
{
    long a0;   // 定义私有成员 a0
    public:
    a(long b)
    {
        a0=b;
    }
    void geta()
    {
        cout<<a0<<endl;
    }
};
int main()
{
    a b(5);          // 定义对象b，并给 b 中的 a0 赋初值
    long *p;
    p=(long*)&b;     // 令指针 p 指向 b 中前 4 个字节，在这里相当于指向 a0
    b.geta();        // 用内部函数访问 a0
    cout<<*p<<endl;  // 在外部直接访问 a0
    *p=8;            // 在外部改变 a0 的值
    b.geta();        // 输出改变后的结果
    cout<<*p<<endl;
    return 0;
}

使用这种方法虽然可以用于基于类的多态原则的一些程序开发，但违反了类的封装原则，在使用指针的类中也极不安全，所以不建议使用

C++ 中的 struct 对 C 中的 struct 进行了扩充，它已经不再只是一个包含不同数据类型的数据结构了，它已经获取了太多的功能。

struct 能包含成员函数吗？能！

struct 能继承吗？能！！

struct 能实现多态吗？能！！！

既然这些它都能实现，那 struct 和 class 还能有什么区别？

最本质的一个区别就是默认的访问控制，体现在两个方面：

1）默认的继承访问权限。struct是public的，class是private的。

你可以写如下的代码：

struct A
{
    char a;
};
struct B : A
{
    char b;
};

这个时候 B 是 public 继承 A 的。

如果都将上面的 struct 改成 class，那么 B 是 private 继承 A 的。这就是默认的继承访问权限。

所以我们在平时写类继承的时候，通常会这样写：

struct B : public A

就是为了指明是 public 继承，而不是用默认的 private 继承。

当然，到底默认是 public 继承还是 private 继承，取决于子类而不是基类。

我的意思是，struct 可以继承 class，同样 class 也可以继承 struct，那么默认的继承访问权限是看子类到底是用的 struct 还是 class。如下：

struct A{}; 
class B : A{}; //private继承
struct C : B{}; //public继承

2）struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。

注意我上面的用词，我依旧强调 struct 是一种数据结构的实现体，虽然它是可以像 class 一样的用。我依旧将 struct 里的变量叫数据，class 内的变量叫成员，虽然它们并无区别。

其实，到底是用 struct 还是 class，完全看个人的喜好，你可以将你程序里所有的 class 全部替换成 struct，它依旧可以很正常的运行。但我给出的最好建议，还是：当你觉得你要做的更像是一种数据结构的话，那么用 struct，如果你要做的更像是一种对象的话，那么用 class。

当然，我在这里还要强调一点的就是，对于访问控制，应该在程序里明确的指出，而不是依靠默认，这是一个良好的习惯，也让你的代码更具可读性。

说到这里，很多了解的人或许都认为这个话题可以结束了，因为他们知道 struct 和 class 的“唯一”区别就是访问控制。很多文献上也确实只提到这一个区别。

但我上面却没有用“唯一”，而是说的“最本质”，那是因为，它们确实还有另一个区别，虽然那个区别我们平时可能很少涉及。那就是：“class” 这个关键字还用于定义模板参数，就像 “typename”。但关键字 “struct” 不用于定义模板参数。这一点在 Stanley B.Lippman 写的 Inside the C++ Object Model 有过说明。

问题讨论到这里，基本上应该可以结束了。但有人曾说过，他还发现过其他的“区别”，那么，让我们来看看，这到底是不是又一个区别。还是上面所说的，C++ 中的 struct 是对 C 中的 struct 的扩充，既然是扩充，那么它就要兼容过去 C 中 struct 应有的所有特性。例如你可以这样写：

struct A //定义一个struct
{
    char c1;
    int n2;
    double db3;
};
A a={'p',7,3.1415926}; //定义时直接赋值

也就是说 struct 可以在定义的时候用 {} 赋初值。那么问题来了，class 行不行呢？将上面的 struct 改成 class，试试看。报错！噢~于是那人跳出来说，他又找到了一个区别。我们仔细看看，这真的又是一个区别吗？

你试着向上面的 struct 中加入一个构造函数（或虚函数），你会发现什么？

对，struct 也不能用 {} 赋初值了。

的确，以 {} 的方式来赋初值，只是用一个初始化列表来对数据进行按顺序的初始化，如上面如果写成 A a={'p',7}; 则 c1,n2 被初始化，而 db3 没有。这样简单的 copy 操作，只能发生在简单的数据结构上，而不应该放在对象上。加入一个构造函数或是一个虚函数会使 struct 更体现出一种对象的特性，而使此{}操作不再有效。

事实上，是因为加入这样的函数，使得类的内部结构发生了变化。而加入一个普通的成员函数呢？你会发现{}依旧可用。其实你可以将普通的函数理解成对数据结构的一种算法，这并不打破它数据结构的特性。

那么，看到这里，我们发现即使是 struct 想用 {} 来赋初值，它也必须满足很多的约束条件，这些条件实际上就是让 struct 更体现出一种数据机构而不是类的特性。

那为什么我们在上面仅仅将 struct 改成 class，{} 就不能用了呢？

其实问题恰巧是我们之前所讲的——访问控制！你看看，我们忘记了什么？对，将 struct 改成 class 的时候，访问控制由 public 变为 private 了，那当然就不能用 {} 来赋初值了。加上一个 public，你会发现，class 也是能用 {} 的，和 struct 毫无区别！！！

做个总结，从上面的区别，我们可以看出，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。

C ++ 객체 지향 - 및 객체 클래스