静态成员变量:
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;
}