类和对象

概念

类是一个抽象的概念和描述，对象是类的一个具体的对象。一个人也可以是一个类，这个类有姓名，年龄，身高，体重…小明就是一个具体的对象。

封装和访问

类的封装

用class关键字对类进行封装，封装类的行为。
语法：
　　class 类名
　　{
　　　　//成员变量；
　　　　//成员函数；
　　};

访问控制

根据类提供的访问修饰符来进行访问类的成员，不显示说访问修饰符，默认所有的成员变量和成员函数都是私有的。

访问修饰符
公有的	public
保护的	protect
私有的	private

//
案例：
版本一：

    #include <iostream>
    using namespace std;

    class Student
    {
        //类的内部
    private: //对于私有的在成员变量和函数，在类的内部可访问，类的外部不可访问
      　int age;
    public: //对于公有的成员变量和函数，在类的内部可访问，类的外部可访问
        char name[20];
    protected: //对于保护的成员变量和函数，在类的内部可访问，类的外部不可访问
        int money;
     //一般情况下，封装类一般会封装成员变量的接口(方法) ,把函数在类的内部实现
    public:
        void set_age(int a)
        {
            age = a;
        }
        int get_age()
        {
            return age;
        }
        //打印数据
        void print_data()
        {
            cout << "age = " << age << "name = " << name << "money = " << money << endl;
        }
    }
    int main(void)
    {
        //类的外部
        Student s1;  //创建对象，对象在栈区
         s1.set_age(20);
         strcpy(s1.name,"zhang3");
         //s1.age = 19; private,私有成员变量，类外不能访问只能通过类中的publi成员函数进行访问
         // s1.money = 10000; protected
		
		Student* s2 = (Student*)malloc(sizeof(Student)); //创建对象，对象在堆区，但是在C++中，不使用
                                                		  //malloc在堆区创建对象,而是采用运算符new来创建堆对象
	    strcpy(s2->name,"5555");
   		s2->print_data();
    	//s1.print_data();
		
    }

版本二: 在类的外部实现成员函数

class student
{

private:
    int age;
    char name[20];

public:
    void print_data(); //类中只声明函数
    void set_age(int a);
    void set_name(char* n);
    char* get_name();
    int get_age();


};

//只说明该函数是一个全局函数，并不属于student
void student::print_data()
{
     cout << "age = " << this->age << "name = " << name  << endl;
}

void student::set_age(int a)
{
    age = a;//this->age = a;
}

void student::set_name(char *n)
{
   strcpy(name,n); //this->name = n
}

类的三大特性：封装、继承、多态

类的构造函数

构造函数语法

类名（参数列表）
　　｛
　　
　　｝
特性：

构造函数：函数名就是名类，并且无返回值
系统会提供一个无参的构造函数，如果实现构造函数，则默认构造函数不复存在
构造函数可以重载
构造函数在实例化对象时，被执行
构造函数的作用通常是用来初始化成员函数，提高程序的安全性

//无参构造函数
    student()
    {
        cout << "无参的构造函数" << endl;
    }
//有参构造函数
 student(int age)
    {
        //this++;  // error student* const this
        cout << "一个参数的构造函数" << endl;
        this->age = age; //this是一个指针
    }
    student(int age,char* name)
    {
        cout << "两个参数的构造函数" << endl;
        this->age = age;
        strcpy(this->name,name);
    }

案例：

#include <iostream>
#include <cstring>
using namespace std;

class student
{
private:
    int age;
    char name[20];
public:
    void print_data(); //类中只声明函数
    void set_age(int a);
    void set_name(char* n);
    char* get_name();
    int get_age();
    
    //构造函数:函数名就是名类，并且无返回值
    student()
    {
    }
    student(int age)
    {
        //this++;  // error student* const this
        cout << "一个参数的构造函数" << endl;
        this->age = age; //this是一个指针
    }
    student(int age,char* name)
    {
        cout << "一个参数的构造函数" << endl;
        this->age = age;
        strcpy(this->name,name);
    }
};

//只说明该函数是一个全局函数，并不属于student
void student::print_data()
{
     cout << "age = " << this->age << "name = " << name  << endl;
}
void student::set_age(int a)
{
    age = a;//this->age = a;
}
void student::set_name(char *n)
{
   strcpy(name,n); //this->name = n
}
int main()
{
    //方法一
    s1.set_age(20);
    s1.set_name("zhang3");
    s1.print_data();
 	//方法二
    student s2(18); // student(student* const this,int age)
    s2.set_name("li4");
    s2.print_data();
	//方法三
	student s3（20,"zhangsan"）; 
	 s3.print_data();
	//方法四
    student* s4 = (student*)malloc(sizeof(student));
    s4->set_age(30);
    s4->set_name("wang5");
    s4->print_data();
    
    return 0;
}

C++ Day02