C++入门篇六

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

struct和class的访问权限:结构体，类

struct和class 是相同的，唯一的而不同，就是默认权限，struct是public，class默认是private

class  Animal {
public://如果不申明权限，默认是私有权限

    char  name[];

    void  eat() {

        cout << "age:" << name << endl;

    }

};

struct  Person1 {

    char  name[];

    void  eat() {

        cout << "name:" << name << "吃饭" << endl;

    }

};

void test() {

    Person1  p1;

    p1.name;//struct默认是共有的权限

    Animal  A1;

    A1.name;//不能访问，class默认是私有的权限

}

protected:保护权限，类内部(不包括继承的子类）是可以访问（属性和方法），类外部是不可以访问的

public公有权限：类的外部和内部都可以访问类里面的属性和方法

private:类内部（包括继承的子类）才可以访问，外部不可以访问

#include "pch.h"

using  namespace  std;

#include <iostream>

#include <string>

//访问权限

class  Person2 {

public:

    void  setage(int n) {

        if (n <  or n>) {

            cout << "不符合" << endl;

            return;

        }

        age = ;

    };

    int  getage() {

        return  age;

    }

    string  getname() {

        return  name;

    }

private:

    int  age;

    string  name;

    int  money;

};

void  test02() {

    Person2 p1;

    p1.setage();

    age=p1.getage;

    name=p1.getname();

};

int  main() {

    test02();

}

构造函数和析构函数 ：

构造函数写法,自动调用，只会调用一次

与类名相同，没有返回值，可以有多个参数，可以发生重载,不写void

构造函数由编译器自动调用，不是手动，而且只会调用一次

析构函数

与类名相同，类名前面加一个符号"~",也没有返回值,不写void，不可以有参数（不能发生重载）,只会调用一次

// 类和对象.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

//

#include "pch.h"

#include <iostream>

using  namespace  std;

//构造函数和析构函数

class  Person {

public:

    //构造函数写法,自动调用，只会调用一次

    //与类名相同，没有返回值，可以有多个参数，可以发生重载,不写void

    //构造函数由编译器自动调用，不是手动，而且只会调用一次

    Person(int a) {//里面是可以传参数进来的

        cout << "构造函数" << endl;

    };

    //析构函数

    //与类名相同，类名前面加一个符号"~",也没有返回值,不写void，不可以有参数（不能发生重载）,只会调用一次

    ~Person()

    {

        cout << "析构函数" << endl;

    }

};

int  main() {

    Person  p1();//默认是会调用构造函数和析构函数的，是系统提供的两个空实现的函数

}

构造函数分类：

有参无参来分：

无参构造函数,有参构造函数

类型来分：

普通构造函数,拷贝构造函数

//分类

//按照参数进行分类

/*

按照参数进行分类：无参构造函数（默认构造函数），有参构造函数

按照类型进行分类，普通构造函数和拷贝构造函数

构造函数和析构函数必须在public下才能调用到

*/

class  Person {

public:

    //构造函数

    Person() {

        //无参构造函数

    }

    Person(int  a) {

        //有参构造函数

        cout << "有参构造函数" << endl;

    }

    Person(const  Person  &p) {

        //拷贝构造函数,前面必须加const，拷贝过来的不能再修改了，固定的，就是说你拷贝过来了张三，不能再修改成张四(p.name="")，只能是原版张三

        //传过来的&p是对象，p就是指针

        age = p.age;//age被赋值

        cout << "拷贝构造函数" << endl;

    }

    ~Person()

    {

        cout << "析构函数" << endl;

    }

    int  age;

};

void  test01() {

    /*

    Person  p1(12);//进入的有参构造函数

    p1.age = 13;

    Person  p2(p1);//这里开始拷贝p1

    */

    //显示法调用

    Person p4 = Person();//有参构造函数

    Person p5 = Person(p4);//这个是拷贝构造函数

    Person();//匿名对象，匿名对象特定，如果编译器发现了是匿名对象的话，那么会在代码结束的时候释放这个对象,这个也是一个匿名函数

    cout << "over" << endl;

    //执行完over之后，发现有两个匿名函数，所以会释放两次这个对象，析构函数

}

int  main() {

    test01();

}