类和对象的特性

基本概念：

1、对象：对象由数据和函数两部分组成

2、封装：可以对一个对象进行封装处理，把数据和针对数据的操作封装在一起，形成一个类，这个类的一部分数据（属性）和成员函数（功能）声明为私有（private），对外界屏蔽。

3、声明类的类型

目录

基本概念：

声明类的类型

3、定义对象

4、类和结构体的异同

5、在类外定义成员函数

6、内置成员函数（inline成员函数）

访问对象的成员

7、类的封装性和信息隐蔽

---

声明类的类型

1、声明结构体类型的方法

只包括数据变量没有操作以下：

struct Student//声明一个结构体
{
    int num;
    char name[20];
    char sex;
};
Student stud1,stud2;//定义两个结构体变量stud1和stud2

2、声明一个类

class Student
{
    int num;//数据成员
    char name[20];
    char sex;
    void display()//成员函数
    {
    cout<<"num:"<<num<<endl;
    cout<<"name:"<<name<<endl;
    cout<<"sex:"<<sex<<endl;
    }
};
Student stud1,stud2;//定义两个Student类的对象stud1和stud2

如果在类中定义既不指明private（私有），也不指定public（公用），则系统就默认是私有的。

被声明为私有（private)成员只能被本类中的成员引用，类外不能调用。

被声明为公用(public)成员既能被本类中的成员引用，类外也能调用。

class 类名
{
    private:
        私有的数据和成员函数；
    public:
        公用的数据和成员函数；
};

3、定义对象

a、先声明类类型，然后再定义对象

Student stud1,stud2;//Student是已经声明的类型
//或者
class 类名 对象名;

b、在声明类的同时定义对象

class Student
{
    public:
        void display()
    {
        cout<<"num:"<<num<<endl;
        cout<<"name"<<name<<endl;
        cout<<"sex:"<<sex<<endl;
    }
    private:
    int num;
    char name[20];
    char sex;
}stud1,stud2;//定义了两个Student类的对象
//在定义Student类的同时，定义了两个Student类的对象

4、类和结构体的异同

1、用struct声明的类，如果对其成员不作private和public的声明，系统将其默认为public（公用的）。

用class定义的类，如果不作private和public的声明，系统将其默认为private（私有的）.

5、在类外定义成员函数

class Student
{
    public:
        void display();//公用成员函数原型声明
    private:
    int num;
    char name[20];
    char sex;
   
}；//对名为Student的类进行声明
void Student::display()//在类外定义display函数
{
    cout<<"num:"<<num<<endl;
    cout<<"name:"<<name<<endl;
    cout<<"sex:"<<sex<<endl;
}
Student stud1,stud2;//定义两个对象

“：：”是作用域限定符，用它声明函数是属于哪个类。

如果在类外定义成员函数，注意先在类体中作原型声明，然后在类外定义。

6、内置成员函数（inline成员函数）

c++要求对一般的内置函数要用关键字inline声明，但对类内成员函数，可以省略inline，因为这些成员已被隐含地指定为内置函数。

eg:

class Student
{
    public:
    viod display()//也可以写成inline void display
    {
        cout<<"num:"<<num<<endl;
        cout<<"name:"<<name<<endl;
        cout<<"sex:"<<sex<<endl;
    }
    private:
    int num;
    char name[20];
    char sex;
};

如果成员函数不在类体内定义，而在类外定义，系统并不把它默认为内置函数，调用这些成员函数的过程和一般函数的过程是相同的。

如果想将这些成员函数指定为内置函数，应当用inline作显示声明。

eg:

calss Student
{
    public:
        inline void display();//声明成员函数为内置函数
    private:
        int num;
        char name[20];
        char sex;
};
inline void Student::display()//在类外定义dispaly函数为内置函数
{
    cout<<"num:"<<num<<endl;
    cout<<"name:"<<name<<endl;
    cout<<"sex:"<<sex<<endl;
}

如果在类外定义inline函数，则必须将类的声明和成员函数的定义都放在同一个头文件中（或者写在同一源文件中），否则编译时无法进行置换（将函数代码的拷贝嵌入到函数调用点）。

访问对象的成员

有三种：public（公用的）；private（私有的）；protected（被保护的）

访问对象中的成员有三种方法：

1、通过对象名和成员运算符访问对象中的成员

但应该注意：

在类外只能访问public成员，而不能访问private成员。

stud1.num=1001;//假设num已定义为公用的整形数据木成员
//其中“.”是成员运算符
//对象名.成员名
stud1.display();//调用对象stud1的公用成员函数

2、通过指向对象的指针访问对象中的成员

class Time
{
    public:
    int hour;
    int minute;
};
Time t,*p;//定义对象t和指针变量p
p=&t;//使p指向对象t
cout<<p->hour;//输出p指向对象中的成员hour

在p指向t的前提下，p->hour,(*p).hour和t.hour三者等价。

3、通过对象的引用来访问对象中的成员

Time t1;//定义对象t1
Time &t2=t1;//定义Time类引用t2，并使之初始化为t1
cout<<t2.hour;//输出对象t1中的成员hour
//由于t2与t1共占用一段存储单元（即t2是t1的别名),因此t2.hour就是t1.hour

7、类的封装性和信息隐蔽

一个c++程序是由3个部分组成的：1、类声明头文件（后缀为.h或无后缀）；2、类实现文件（后缀为.cpp)，包括类成员函数的定义；3、类的使用文件（后缀为.cpp）即主文件。

1、类声明头文件

//student.h(这是名为student.h的头文件，在此文件中进行类的声明
#include <string)
using namespace std;
class Student
{
    public:
        void dispaly();
    private:
        int num;
        string name;
        char sex;
};

2、包含类成员函数的定义的文件（即类实现文件）

//student.cpp(在此文件中进行函数的定义）
#include <iostream>
#include "student.h"
void Student::dispaly()//在类外定义dispaly函数
{
    cout<<"num:"<<num<<endl;
    cout<<"name:"<<name<<endl;
    cout<<"sex:"<<sex<<endl;
}

3、主文件，为了组成一个完整的源程序，还应当包括主函数的源文件

//main.cpp(主函数模块）
#include<iostream>
#include"student.h"//将类声明头文件包含进来
using namespace std:
int main()
{
    Student stud;//定义对象stud
    stud.dispaly();//执行stud对象的dispaly函数
    return 0；
}