C++04

Posted on
Words count in article: 2.1k | Reading time ≈ 9

Day04 总结

静态变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//静态成员变量与一般的数据成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝 静态成员变量，属于某个类，所有对象共享
//1 静态成员必须再类中声明，在类外定义
//2 静态数据成员不属于某个对象，在为对象分配空间中不包静态成员所占的空间
//3 静态数据成员可通过类名或者对象名来引用
#include<bits/stdc++.h>
using namespace std;
class Person
{
public:
    //静态成员变量
    //1，共享
    //2. 在编译阶段就分配了内存
    //3，在类内声明，在类外初始化
    static int m_A;
    void fuc2()
    {
        m_A = 200; // 非静态成员函数，可以访问两种变量
    }
    static void fuc()
    {
//         m_C = 100;//静态成员函数 是不可以访问非静态成员变量的
        m_A = 100;//静态成员函数 可以访问静态成员变量 ，因为都是共享数据
        cout<<"静态成员函数的调用"<<endl;
    }

//    int m_C ;
private:
    static int m_B;//私有权限的数据，类外访问不到
};
int Person::m_A=10;
int Person::m_B=20;
void test01()
{
    //访问方式
    //1.通过对象进行访问

    Person p1;
    cout<<p1.m_A<<endl;
    Person p2;
    p2.m_A = 20;
    cout<<p1.m_A<<endl;
    cout<<p2.m_A<<endl;//都变20；
    //通过类名进行访问
    cout<<"m_A = "<<Person::m_A<<endl;
}
void test02()
{
    //1 通过对象可以进行调用
    Person p1;
    p1.fuc();
    //2.通过类名进行调用
    //3 静态成员函数 也是有访问权限的，私有的权限类外访问不到
}

单例模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Printer{
public:
    static Printer *getInstance()
    {
        cout<<"单例调用"<<endl;
        return printer;
    }
    //打印操作
    void printTest(string test)
    {
        m_Count ++;
        cout<<"打印的内容：："<<test<<endl;
    }
    int m_Count = 0;
private:

    static Printer *printer;
    Printer(){
        cout<<"构造调用"<<endl;

    }
    Printer(const Printer &p)
    {
    }
};
Printer *Printer::printer = new Printer();//中间的Printer是作用域，作用在类里面
void test01()
{
    Printer *p1 = Printer::getInstance();//这里用p1->getInstance也可以的
    p1->printTest("入职申请");
    p1->printTest("离职申请");
    p1->printTest("旅游申请");
    p1->printTest("请假申请");
    cout<<"使用打印机的次数::"<<p1->m_Count <<endl;
    Printer *p2 = Printer::getInstance();
    p2->printTest("调休");
    cout<<"使用打印机的次数::"<<p2->m_Count <<endl;

}

面向对象模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Person{
public:
    int m_A;//成员属性 算在类的大小中
    void func()
    {}

    static int m_B;//静态成员变量，不属于类的大小中
    static void func2()//静态成员函数，不属于类的大小中
    {}
    int m_C;//sizeof+4
    double m_D;//sizeof+8
};
int Person::m_B = 0;
void test01()
{
    //空类大小为：：1
    //空类也可以实例化的，每个对象在内存中应该都有独一无二的地址
    //Person p[10];    p[0]
    cout<< sizeof(Person)<<endl;
}

this指针的基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* Created by Jason on 2020/3/24.
1.this 指针指向的是被调用的成员函数所属的对象
2.*this 对象本体
3.this 可以解决名称冲突
链式编程*/


#include<bits/stdc++.h>
using namespace std;
class Person{
public:
    Person(int age)
    {
        //this 指针指向的是被调用的成员函数所属的对象
        this->age = age;
//        age = age;
    }
    void showAge()
    {
        cout<<"年龄"<<this->age<<endl;
    }
    Person& AddAge(Person &p)
    {
        this->age +=p.age;
        return *this;
    }
    int age;
};
void test01()
{
    Person p1(18);
    cout<<p1.age<<endl;//解决名称冲突
    p1.showAge();
    Person p2(10);
    p1.AddAge(p2).AddAge(p2);
    p1.showAge();
}

空指针访问成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*如果是一个空指针 可以访问没有this 的一些成员函数
如果函数中用了this指针，程序会down掉
严谨的写一下加上if判断*/
#include<bits/stdc++.h>
using namespace std;
class Person{
public:
    int m_Age;
    void showCLassName()
    {
        cout<<"classNAme is Person"<<endl;
    }
    void showAge()
    {
        //NULL ->m_age;//需要用if(this ==NULL)判断

        cout<<"AGE ="<< this->m_Age<<endl;
    }
};
void test01()
{
//     Person p1;
//    p1.m_Age = 18;
//    p1.showAge();
//    p1.showCLassName();
    Person *p1 = NULL;
//    p1->showAge();//会报错
    p1->showCLassName();//没有用this指针，不报错
}

常含数与常对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*
 *this 本质是指针常量 type *const this
 *      1.1指针的指向是不能修改的，指针指向的值可以改
 *      1.2要想让值都不能改，需要在函数的括号后加上const
 *有些特例的属性，即使在长函数或者常对象中都可以修改，需要加上mutable
 * 常对象 const Person p；
 * 常对象，是不可以调用普通成员函数的，只能调用常函数
 * */
#include<bits/stdc++.h>
using namespace std;
class Person{
public:
    int m_A;
    mutable int m_B;//加了这个关键字，即使是常函数，m_A也可以修改
    //《成员函数》声明后面加上const 代表常函数，不可以修改成员属性了
    void showPerson()const
    {
        //Person *const this
        //This 指针的本质是一个指针常量，指针指向是不能修改的，指针指向的值可以改
        //要想让值都不能改，需要在函数的括号后加上const
        cout<<this->m_A<<endl;
    }
    void showPerson2()
    {
        cout<<"aaa"<<endl;
    }
};
void test01()
{
    Person p1;
    p1.m_A = 10;
    p1.showPerson();

}

//常对象
void test02()
{
    const Person p2{};//常对象
    //常对象不可以修改内部属性
	//p2.m_A = 20;会报错
    p2.m_B =100;//常对象，只能调用常函数
    //p2.showPerson2();//常对象，是不可以调用普通成员函数的
}

全局函数作为友元函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*友元
 *  1.1 有一个全局函数作为本类的友元函数，可以访问到私有内容
 *  1.2类的内部写入friend+函数声明
 * */
#include<bits/stdc++.h>
using namespace std;
class Building{
    //有一个全局函数作为本类的友元函数，可以访问到私有内容
    friend  void goodGay(Building &building);
public:
    Building()
    {
        this->m_SittingRoom = "客厅";
        this->m_BedRoom = "卧室";
    }

    string m_SittingRoom;
private:
    string m_BedRoom;
};
//好基友全局函数
void goodGay(Building &building)
{
    cout<<"好基友正在访问"<<building.m_SittingRoom<<endl;
    cout<<"好基友正在访问"<<building.m_BedRoom<<endl;
    //直接这样写是访问不到Bedroom的，要在class里加上友元
    //加上以后就可以访问了
}
void test01()
{
    Building b;
    goodGay(b);
}

类作为友元类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*类作为友元类
 * 1有缘关系不能被继承
 * 2友元关系是单向的，类A 是类B的朋友。但类B不一定是类A的朋友
 * 3友元关系不具有传递性。类B是类A的盆友，类C是类B的朋友，但类C不一定是类A的朋友
 *      告诉编译器 goodGay是友元类，可以访问里面的私有内容
 *      在类的内部写入 friend class 类名
 * */
#include<bits/stdc++.h>
using namespace std;
class Building;//先让ide不要报错
class goodGay{
public:
    goodGay();
    void visit();
private:
    Building *building;
};
class Building{
    //告诉编译器 goodGay是友元类，可以访问里面的私有内容
    friend class goodGay;
    //虽然goodGay中可以访问Building类，但Building类中不能访问goodGay

public:
    Building();

    string m_SittingRoom;
private:
    string m_BedRoom;
};
//类外做函数实现
goodGay::goodGay() {
this->building = new Building;
}

void goodGay::visit() {
    cout<<"GoodGAy is visiting"<<this->building->m_SittingRoom<<endl;
    cout<<"GoodGAy is visiting"<<this->building->m_BedRoom<<endl;
    //如果不声明友元类，在这里访问的话就会报错

}
Building::Building() {
    this->m_BedRoom = "卧室";
    this->m_SittingRoom = "客厅";
}
void test01()
{
    goodGay gg;
    gg.visit();
}

成员函数作为友元函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/*成员函数作为友元函数
 *      告诉编译器， goodGay中的visit可以访问Building类中的私有内容
        friend void goodGay::visit() ;
 * */

#include<bits/stdc++.h>
using namespace std;
class Building;//先让ide不要报错

class goodGay{
public:
    goodGay();
    void visit();//visit 可以访问Building 中的私有属性
    void visit2();//visit2 不可以
private:
    Building *building;
};

class Building{
    //告诉编译器， goodGay中的visit可以访问Building类中的私有内容
    friend void goodGay::visit() ;
public:
    Building();
    string m_SittingRoom;
private:
    string m_BedRoom;
};

//类外做函数实现
goodGay::goodGay() {
    this->building = new Building;
}

void goodGay::visit() {
    cout<<"GoodGAy is visiting"<<this->building->m_SittingRoom<<endl;
    cout<<"GoodGAy is visiting"<<this->building->m_BedRoom<<endl;
    //如果不声明友元类，在这里访问的话就会报错

}

void goodGay::visit2() {
    cout<<"BAD GAy is visiting"<<this->building->m_SittingRoom<<endl;
//    cout<<"BAD GAy is visiting"<<this->building->m_BedRoom<<endl;

}

Building::Building() {
    this->m_BedRoom = "卧室";
    this->m_SittingRoom = "客厅";
}
void test01()
{
    goodGay gg;
    gg.visit();
    gg.visit2();
}
-------------本文结束，感谢您的阅读-------------