7.1 静态成员变量和静态成员函数
7.1.1 静态成员变量
- 关键字 static 可以用于说明一个类的成员；
- 静态成员提供了一个同类对象的共享机制；
- 把一个类的成员说明为 static 时，这个类无论有多少个对象被创建，这些对象共享这个 static 成员
静态成员局部于类，它不是对象成员，在类的外部进行初始化。
7.1.2 静态成员函数
- 静态成员函数冠以关键字static；
- 静态成员函数提供不依赖于类数据结构的共同操作，它没有this指针；
- 在类外调用静态成员函数用 “类名 :: ”作限定词，或通过对象调用。
疑难问题：静态成员函数中，不能使用普通变量，只能使用静态成员变量。
7.1.3 总结
- 所有同类对象共享同一个静态成员变量；
- 静态成员变量一定要在类的外部初始化；
- 静态成员函数内部只能访问静态成员变量，不能访问普通变量；
- 静态成员变量可以直接通过类名来访问
- 静态成员函数可以通过类名直接访问
#include <iostream>
using namespace std;
class Student
{
public:
static int count; //静态成员变量 所有对象共享同一个静态成员变量
private:
int id;
public:
Student()
{
count++;
id = count;
}
static int getCount() //静态成员函数
{
//id++; //静态成员函数内部只能访问静态成员变量，不能访问普通变量（这里报错）
return count;
}
};
//注：静态成员变量一定要在类的外部初始化
int Student::count = 0;
int main()
{
Student s1;
Student s2;
cout << Student::count << endl; //静态成员变量可以直接通过类名来访问
cout << s1.getCount() << endl;
cout << Student::getCount() << endl; //静态成员函数可以通过类名直接访问
return 0;
}
运行结果：
7.2 面向对象模型
7.2.1 基础知识
-
C++中的class从面向对象理论出发，将变量(属性)和函数(方法)集中定义在一起，用于描述现实世界中的类。从计算机的角度，程序依然由数据段和代码段构成。
-
C++编译器如何完成面向对象理论到计算机程序的转化？
换句话：C++编译器是如何管理类、对象、类和对象之间的关系？
具体的说：具体对象调用类中的方法，那，c++编译器是如何区分，是那个具体的类，调用这个方法那?
7.2.2 编译器对成员变量和成员函数的处理机制
-
通过上面的案例，我们可以的得出：
C++类对象中的成员变量和成员函数是分开存储的 -
（1）成员变量：
普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对齐方式
静态成员变量：存储于全局数据区中
-
（2）成员函数：
存储于代码段中。
问题出来了：
很多对象共用一块代码？代码是如何区分具体对象的那？
换句话说：int getK() const { return k; }，代码是如何区分，具体obj1、obj2、obj3对象的k值？==>(通过 this 指针）
7.2.3 总结
- 1、C++类对象中的成员变量和成员函数是分开存储的。C语言中的内存四区模型仍然有效
- 2、C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。
- 3、静态成员函数与普通成员函数的区别：
静态成员函数不包含指向具体对象的指针
普通成员函数包含一个指向具体对象的指针
#include <iostream>
using namespace std;
class Test
{
private:
int a;
char b;
public:
Test(int _a)
{
this->a = _a;
}
void show() //等价于void show(Test *this) 所有的成员函数隐藏了一个参数 this指针
{
cout << this->a << endl;
}
};
int main()
{
Test t1(0);
cout << sizeof(t1) << endl; //不包含静态成员变量
Test t2(1);
t1.show(); //等价于 t1.show(&t1);
t2.show(); //等价于 t2.show(&t2);
return 0;
}
运行结果：
7.2.4 const修饰成员函数
- const关键字写在函数名的后面；
- 常函数只能访问访问变量，不能修改变量。
示例代码：
#include <iostream>
using namespace std;
class Test
{
private:
int a;
int b;
public:
Test()
{
a = 0;
b = 1;
}
void show() const //注意位置 常函数
{
//a++; //常函数只能访问变量，不能修改变量（所以这里会报错）
cout << a << " " << b << endl;
}
};
int main()
{
Test t1;
t1.show();
return 0;
}
运行结果：
7.2.5 全局函数和成员函数
- 1、把全局函数转化成成员函数，通过this指针隐藏左操作数
Test add(Test &t1, Test &t2) ===》 Test add(Test &t2)
- 2、把成员函数转换成全局函数，多了一个参数
void printAB() ===》 void printAB(Test *pthis)
- 3、函数返回元素和返回引用
Test& add(Test &t2) //*this //函数返回引用
{
this->a = this->a + t2.getA();
this->b = this->b + t2.getB();
return *this; //*操作让this指针回到元素状态
}
Test add2(Test &t2) //*this //函数返回元素
{
//t3是局部变量
Test t3(this->a+t2.getA(), this->b + t2.getB()) ;
return t3;
}
代码示例：
#include <iostream>
using namespace std;
class Test
{
friend void show(Test &t); //声明友元函数
private:
int a;
public:
Test()
{
a = 100;
}
void show()
{
cout << this->a << endl;
}
};
void show(Test &t) //成员函数改成全局函数 需要添加一个参数
{
//cout << a << endl; //a是成员变量 通过对象来访问（这里会报错）
cout << t.a << endl; //友元函数可以访问类的私有成员变量
}
int main()
{
Test t1;
t1.show();
show(t1);
return 0;
}
运行结果：
7.3 友元
7.3.1 友元函数
友元函数不是类的内部函数，是一个全局函数，但是可以改变类的私有属性
友元函破坏了类的封装性
7.3.2 友元类
若B类是A类的友员类，则B类的所有成员函数都是A类的友员函数
友员类通常设计为一种对数据操作或类之间传递消息的辅助类
示例代码：
#include <iostream>
using namespace std;
class A
{
friend class B; //友元类 可以在类B中访问类A的私有成员变量
private:
int a;
};
class B
{
public:
void print(A &ta)
{
cout << ta.a << endl;
}
};
int main()
{
return 0;
}
