c++第三天:

本文深入探讨C++的静态成员变量与函数特性,解析单例模式实现,揭示对象模型及this指针工作原理,讲解const与mutable修饰符作用,以及友元机制的应用。同时,文章还介绍了模板类的声明实现分离技巧。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

静态成员变量:
c++的静态成员变量必须在类外初始化,编译器不允许直接赋值初始化,在构造函数中初始化,又会造成每个对象初始化一次的情况。

class Person{
public:
    static int age;
    static void func(){	//静态成员函数只能访问静态变量,但普通成员函数可以访问任何函数
		cout << "hello world" << endl;
	};
};
int Person::age = 10;
int main(){
	cout << Person::age << endl;
	cout << Person::func() <<  endl;
	Pserson p;
	cout << p.age << endl;
	cout << p.func() << endl;
}

c++中的单例,相当于iOS中的饿汉式,在类初始化的时候生成这个类的唯一单例

class ChairMan{
private:
    ChairMan(){};
    ChairMan(ChairMan& man){};
    static ChairMan* instance;
public:
    static ChairMan* getInstance(){
        return instance;
    };
};
ChairMan* ChairMan::instance = new ChairMan();

C++中的对象模型:

class Person{
public:
	int a;//非静态成员变量,属于对象身上
	void func(){};//非静态成员函数,不属于对象身上
	static int b;//不属于对象
	static void func2(){};	//不属于对象
}

this:指向调用对象的指针

class Person{
	void func(){
	}
}
int main(){
	Person* p = new Person();
	p->func();
}

这个类在底层实际上实际上是这样的

Class Person{
	void func(Person* this){
	}
}
int main(){
	Person* p = new Person();
	p->func(p);
}

使用this我们可以方便的实现函数式编程

class Add{
public:
    int count;
    Add():count(0){};
    Add* add(){
        count++;
        return this;
    }
};
int main(){
    Add* a = new Add();
    a->add()->add()->add();
    cout << a->count << endl;
}

这里注意,如果返回的时候返回 *this的话,会触发拷贝构造函数,达不到链式编程的效果。
空指针调用函数

class Person(){
private:
	int age;
public:
	void func(){};
	void func2(){
		cout << age << endl;
	};
}
int main(){
	Person p = NULL;
	p.func();	//可以调用成功
	p.func2();	//调用失败,因为this指针为NULL,func2中的age会被转化为this.age,自然失败
}

类中的const和mutable
先看如下函数:

class Person{
private:
    int age = 0;
    mutable int weight = 100;
public:
    void func() const{
        this->age++; 错误!:在常函数中,不能修改普通变量的值!
        this->weight++; //添加了mutable的变量,即使是在常函数中,也是可以修改的
    };
    void func2(){};
};

int main(){
    const Person* p = new Person();
    p->func();	错误!,p是一个常量指针,指向的对象只能调用常量函数!
    p->func2(); //正确
}

这是为什么呢?
Person类中,对于普通函数来说,this指针的定义是这样的

Person const* this;

这里的this是一个指针常量,表示它只能指向调用的对象
对于常量函数,this指针的定义是这样的

const Person const* this;

this同时具有顶层const和底层const的定义,不仅它本身的指向不能被修改,它指向的对象也是不能被修改的。

友元:

友元函数
让外部函数能够访问类的私有成员变量(这里的外部函数可以是全局函数,也可以是类内的成员函数)

class Person{
    friend void firendFunc();	//声明 firendFunc 函数是当前类的友元
private:
    int age;
};

void firendFunc(){
    Person p;
    cout << p.age << endl;
}

友元类:
让外部类能够访问类内部私有变量

class Dog{
    friend class Person;
private:
    int age = 0;
};

class Person{
public:
    void run(){
        Dog d;
        cout << d.age << endl;
    };
};

这里Person是Dog的友元类,因此可以访问Dog的私有变量age

模板类的声明实现分离和hpp文件
对于普通类来说,声明和实现分离后,编译阶段,实现文件会被编译
但是
对于模板类,就不一定了,实现文件不知道真实的变量类型,无法完成编译,这个时候,分离写就会出现问题,于是我们采用类内声明,类外实现,将声明和实现写在同一个文件,这个文件就是hpp文件。

template <class T1,class T2>
class Person {
public:
    Person(T1 name,T2 age);
    void showPerson();

private:
    T1 _name;
    T2 _age;
};
template <class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age):_name(name),_age(age){}

template <class T1,class T2>
void Person<T1,T2>::showPerson() {
    cout << _age << " " << _name << endl;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值