C++学习笔记2（类和对象）

一、C++类和对象的基本概念

1、C++是一种基于过程和面向对象的混合型的语言。

基于过程：函数是构成程序的基本部分，程序面对的是一个个函数。每个函数都是独立存在于程序中，除了主函数只能被操作系统调用外，各个函数可以相互调用。

面向对象：除了主函数外，其他函数都是出现在类中，只有通过类才能调用类中的函数。程序的基本构成单位是类，程序面对的是一个个类和对象。

2、面向对象设计的4个主要特点：抽象、封装、继承和多态性。

对象具有两个要素：属性和行为。c++中数据是属性，函数是行为。

（1）封装：两方面的含义：一将有关的数据和操作代码封装到一个对象中，形成一个基本的单位，各个对象之间相互独立，互不干扰。二是将对象中的某些部分对外隐藏，即隐藏内部细节，只留下少量接口，以便与外界联系。

（2）抽象：对有关事物的共性归纳和集中的过程。抽象的作用是表示同一类事物的本质。类是对象的抽象，而对象是类的特例（类的具体表现形式）。类是抽象的，不占用内存；对象时具体的，占用存储空间。

（3）继承和重用：利用一个已有的类去创建一个新的类，即软件重用。

（4）多态性：由继承产生的不同的派生类，其对象对同一消息会产生不同的响应。

3、类和对象的作用

（1）基于过程的结构化设计中：程序=算法+数据结构

（2）面向对象的设计：对象=算法+数据结构 ；程序=对象（多个）+消息

消息的作用就是对对象的控制，程序设计的关键是设计好每个对象以及确定向这些对象发出的命令。

二、C++类的声明和对象的定义

1、C++类的定义

class 类名
{
    public:
        //公共的行为或属性
 
    private:
        //公共的行为或属性
};

 private 表示该部分内容是私密的, 不能被外部所访问或调用, 只能被本类内部访问; 而 public 表示公开的属性和方法, 外界可以直接访问或者调用。

2、C++对象的定义

方法一：先声明类类型，然后再定义对象

Student stu1; //创建对象,Student是已经声明的类型

另一种写法前面加关键字class

class Student stu1; //创建对象,Student是已经声明的类型

方法二：在声明类的同时定义对象

class Student{
    //成员变量
    char *name;
    int age;
    float score;
    //成员函数
    void say(){
    printf("%s的年龄是 %d，成绩是 %f\n", name, age, score);
    }
    }stu1, stu2;

或者不出现类名，直接定义对象

class{
    //成员变量
    char *name;
    int age;
    float score;
    //成员函数
    void say(){
    printf("%s的年龄是 %d，成绩是 %f\n", name, age, score);
    }
    }stu1, stu2;

三、类的成员函数

1、成员函数：和一般函数基本一样，只是成员函数出现在类中。使用私有成员函数只能被本类中的其他成员函数所调用，而不能被类外调用。成员函数可以访问本类对象中的任何成员。

2、成员函数定义方法

方法一：在类定义时定义成员函数

#include <iostream>
using namespace std;
class Point
{
    public:
        void setPoint(int x, int y) //实现setPoint函数
        {
            xPos = x;
            yPos = y;
        }
 
        void printPoint()       //实现printPoint函数
        {
            cout<< "x = " << xPos << endl;
            cout<< "y = " << yPos << endl;
        }
 
    private:
        int xPos;
        int yPos;
};
 
int main()
{
    Point M;        //用定义好的类创建一个对象 点M
    M.setPoint(10, 20); //设置 M点 的x,y值
    M.printPoint();     //输出 M点 的信息
 
    return 0;
}

方二：在类外定义成员函数

#include <iostream>
using namespace std;
class Point
{
    public:
        void setPoint(int x, int y); //在类内对成员函数进行声明
        void printPoint();
 
    private:
        int xPos;
        int yPos;
};
void Point::setPoint(int x, int y) //通过作用域操作符 '::' 实现setPoint函数
{
    xPos = x;
    yPos = y;
}
void Point::printPoint()       //实现printPoint函数
{
    cout<< "x = " << xPos << endl;
    cout<< "y = " << yPos << endl;
}
int main()
{
    Point M;        //用定义好的类创建一个对象 点M
    M.setPoint(10, 20); //设置 M点 的x,y值
    M.printPoint();     //输出 M点 的信息
 
    return 0;
}

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

3、成员函数的存储方式

         同一类的不同对象的数据成员的值一般是不同的，而不同对象的函数代码是相同的。对于同一个类的不同对象调用同一个成员函数时，C++编译系统会开辟一段空间存放这个共同的函数的目标代码，这样大大节约了存储空间。

         无论成员函数在类内定义还是在类外定义，成员函数的代码段的存储方式是相同的，都不占用对象的存储空间。

        无论是否用inline声明，成员函数的代码段都不占用对象的存储空间。inline函数只影响程序的执行效率，而与成员函数是否占用对象的存储空间无关。

四、C++对象成员的引用

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

方法一：通过对象名和对象成员引用运算符（.）访问对象中的成员

访问对象中数据成员的一般形式为： 
对象名.成员名

定义类

class Data {
public :
    int data;
    void fun(int a,int b,int d);//函数实现在外部
private :
    void add(int m)
    {
        data +=m;
    }
    int x,y;
}

 使用类成员

    void caller1()
{
    Data A, B; //定义对象
    A.fun(1,2); //正确，类外部可以访问类的public成员函数
    A.data=100; //正确，类外部可以访问类的public数据成员
    A.add(5); //错误，类外部不能访问类任何private的成员
    A.x=A.y=1; //错误，类外部不能访问类任何private的成员
    B.data=101; //正确，A.data和B.data是两个对象的数据成员，为不同的存储空间
    B.fun(4,5); //正确，A.fun和B.fun函数调用相同的代码，但作用不同的数据成员
}

 调用对象中成员函数的一般形式为： 
对象名.成员函数(实参列表) 

 方法二：通过指向对象的指针和指针成员引用运算符（->）访问对象中的 

访问对象中数据成员的一般形式为： 
对象指针—>成员名 
调用对象中成员函数的一般形式为： 
对象指针—>成员函数（实参列表）

void caller(){
Data A,*p1,*p2;//定义对象指针变量  Data为类名
    p1=&A;//p1指向对象A
    p1->data=100;
    p1->fun(1,2)
    p2=new Data;//动态分配Data对象
    p2->data=100;
    p2->fun(1,3);
    delete p2;//销毁对象
}

在p1指向对象A的前提下， p1->data=100与（*p1）.data=100与A.data=100三者等价。及使用引用符“->”与引用符“.”效果一样。

方法三：通过对象的引用变量和对象成员引用运算符（.）访问对象中的成 员

访问对象中数据成员的一般形式为： 
对象引用变量名.成员名 
调用对象中成员函数的一般形式为： 
对象引用变量名.成员函数(实参列表)

void caller(){
Data A,&a=A;//定义对象引用变量
a.data=100;
a.fun(1,3);
}

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

1、公用成员函数：

公用成员函数是用户使用类的公用接口，或者说类的对外接口。

2、信息隐蔽：类的公用接口与私有实现的分离。