本专栏目的
- 更新C/C++的基础语法，包括C++的一些新特性
前言
- 通过前面几节，我们介绍了C++的类与对象、构造与析构函数、拷贝等相关知识，这一篇将详细介绍了C++的成员变量相关的知识点与扩展
- C语言后面也会继续更新知识点，如内联汇编；
- 本人现在正在写一个C语言的图书管理系统，1000多行代码，包含之前所学的所有知识点，包括链表和顺序表等数据结构，请大家耐心等待！！预计国庆前写完更新。
文章目录
类中数据与函数储存
C++的数据主要是对类的抽象，类是面向对象的抽象，在C++面向对象程序设计中，主要有两部分：
- C++语言中构造、析构函数、虚函数、继承、多态等是是支持面向对象程序设计直接体现
- C++中这个底层机制为上面这一点做支撑
故从以上点来看类数据储存：
- C++中的类从面向对象理论出发，将变量(属性)和函数(方法)集中定义在一起，用于描述现实世界中的类。
- 从计算机的角度，程序依然由数据段和代码段构成。
接下来思考下面程序运行的结果？，你感觉他会输出的值是多少呢？
class C1
{
public:
int i;
int j;
int k;
static int number; // 静态
};
class C2
{
public:
int i;
int j;
int k;
int getK(){return k;} // 成员函数
void setK(int nk){i = nk;} // 成员函数
};
void test()
{
cout<<"c1:%d "<<sizeof(C1)<<endl;
cout<<"c2:%d "<<sizeof(C2)<<endl;
}
输出结果:
c1:%d 12
c2:%d 12
原因：
- 成员变量
- 普通成员变量：存储在对象中（对象存储位置由创建位置决定），与struct对象有相同的内存布局和字节对齐方式(尤其要注意对其方式)
- 静态成员变量：存储在静态变量区(全局区)，这个下一节也将会详细讲解
- 成员函数
- 存储在代码段中，而对象储存位置由创建的位置决定。
问题出来了：很多对象共用一块代码？代码是如何区分具体对象的那？
换句话说：int getK() { return k; }，代码是如何区分，具体obj1、obj2、obj3对象的k值？
静态(static)成员
C++是对类的抽象，故在C++中类中静态成员分为静态成员变量和静态成员函数，创建静态成员变量和静态成员函数只需要用关键之static
静态成员在内存中存储在全局区，声明周期是从程序开始到结束，故其他成员可以贡献其资源。
静态成员变量
-
static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放，也就是他不占用类的内存空间(类的生命周期是创建到类的销毁，而销毁可能是超出作用域，也可能手动释放)
-
静态成员变量必须在类的内部申明，在类的外部定义，除非是使用内联，因为静态成员变量不属于对象，他在全局区，在类或者结构体中只是声明 ，后面必须要定义
class W
{
static int s_cnt; //类的内部声明
inline static int s_num; //C++17 可以直接内联，就不需要在类的外部定义了
};
int W::s_cnt = 0; //类的外部定义
- 访问权限：既可以使用对象访问，也可以使用类名访问
静态成员函数
- 在类中，static 除了可以声明静态成员变量，还可以声明静态成员函数。
- 使用权限：普通成员函数可以访问所有成员（静态和非静态都可以），静态成员函数只能访问静态成员。
比如说，我们要通过函数获取学生总人数(m_classSize)，有两种方法：
- 定义普通成员函数：可以访问静态成员，但是这个函数只对静态成员进行操作，加上 static 语义更加明确。
- 定义静态成员函数：在函数前面加上static，可以声明为静态函数
静态成员函数调用方式，有两种：
-
和普通成员函数一样，通过对象去调用：
-
Student stu; stu.classSize(); -
不定义对象，直接通过类名::函数名去调用
-
Student::classSize();
思考：为什么静态成员函数不能调用类的非静态成员？
在类的定义中，变量内存分配和函数是不同的，类的内存大小=类的成员变量内存大小，而成员函数是在创建对象的时候要调用的时候创建的，这样有利于节约内存，而静态成员函数存储在全局区，一定义就创建出来了，如果在静态成员函数中调用类的成员函数的话，就会发现那个成员函数根本不存在，总的来说就是：
- 上下文环境不同
- this指向不同
普通成员函数的内部处理
左边为C++代码，右边为C语言代码
其实把C++的类改为C语言，只需要用结构体+函数，然后通过传对象的指针，在函数里面访问即可！(右边的代码)
pthis对象指针与this指针
通过C语言的方式，对成员变量进行修改、赋值…………操作，用C风格方式，可能的采用指针的方法，但是这样也有一个问题，如下：
上面问题就是，pthis这个指针指向修改了，并不是指向原有的位置。
那么有没有什么办法可以让pthis指针在函数里面不能被修改呢？
- 可以给pthis指针加上const属性，让它不能被改变指向
而这个加上const的pthis指针，就是C++的this指针。
注意：
- this 是 C++ 中的一个关键字，也是一个 const 指针，它指向当前对象，在类的内部可以通过它可以访问当前对象的**所有成员*，如下是他的使用操作
class Stu
{
public:
Stu(int age, char* name)
{
this->age = age;
}
private:
int age;
}
- 以上发现，如果函数中形参和类的属性名相同，可以通过this解决。
常(const)成员
在类中，如果你不希望某些数据被修改，可以使用const关键字加以限定。const 可以用来修饰成员变量和成员函数的关键字。
const成员变量
const 成员变量的用法和普通 const 变量的用法相似，只需要在声明时加上 const 关键字。
- 初始化 const 成员变量只有一种方法，就是通过构造函数的初始化列表。
class Test
{
public:
Test() {}; // 报错：error C2789:“Test::a”:必须初始化常量限定类型的对象
const int m_a;
}
- 必须通过构造函数的初始化列表初始化，初始化之后不允许赋值。(但是初始化列表可以)
class Test
{
public:
Test(int a): m_a(8)
{
m_a = 2; // error C2166:左俏指定 const 对象
}
const int m_a;
}
// 注意：这种方法不行
class Test
{
public:
Test(int a){
m_a = a; // 会报错
}
public:
const int m_a;
};
const成员函数
const 成员函数可以使用类中的所有成员变量，但是不能在函数里面修改它们的值，通过const 成员函数也称为常成员函数。
但要注意，类中的常成员函数中的const放的位置有点独特，放在函数后面，如下：
class Text
{
public:
void fix() const // 放到这里
{
m_age = 2; // 会报错
}
private:
int m_age;
}
mutable
在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中，如上面程序可以做修改：
class Text
{
public:
void fix() const // 放到这里
{
m_age = 2; // 这样就不会报错了
}
private:
mutable int m_age;
}
注意
- 常成员函数可以访问任何成员
- 常对象只能访问常函数，这个很容易忽略，但是编译器编译的时候，我们也很容易发现错误更改。
友元(了解即可)
在C++中，私有成员只能在类的成员函数内部访问，如果想在别处访问对象的私有成员，只能通过类提供的接口间接地进行，所以C++引入友元的概念，使得被定义为友元的函数即使在外部，也能访问类中的私有成员。
友元函数
- 全局函数作为友元函数
class GirlFriend
{
//在public之前
friend void stage(GirlFriend& girl);
private:
int data;
public:
GirlFriend(int data)
:data(data)
{}
};
void stage(GirlFriend& girl)
{
GirlFriend t(33);
cout << "data: " << girl.data<<" " << t.data;
}
int main()
{
GirlFriend g(2);
stage(g);
return 0;
}
我们在GirlFriend类中把stage函数声明为了友元函数，这样子就可以在stage函数中访问GirlFriend类的私有成员了~
- 成员函数作为友元函数
class GirlFriend; //必须提前声明
class BoyFriend
{
public:
BoyFriend() = default;
void kissGirlFriend(GirlFriend* girlFriend);
};
class GirlFriend
{
friend void stage(GirlFriend& girl);
friend void BoyFriend::kissGirlFriend(GirlFriend* girlFriend);
private:
int data;
public:
GirlFriend(int data)
:data(data)
{}
};
// 实现顺序一一定要注意
void BoyFriend::kissGirlFriend(GirlFriend* girlFriend) //必须在类外实现
{
cout << "kiss kiss " << girlFriend->data << endl;
}
int main()
{
GirlFriend g(2);
BoyFriend boy;
boy.kissGirlFriend(&g);
return 0;
}
一个类的成员函数作为另一个类的友元函数的时候，这个成员函数必须在类外实现，而且是必须在作为友元的类之后实现。
-
类做友元
-
注意点
- 不能把别的类的私有函数定义为友元。
- 一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员
- 尽量不要用，故了解即可，忘了在查
友元类
//在哪一个类中声明为友元，则本类的**成员函数**就可以访问那一个类的私有成员
class BoyFriend；
class GirlFriend
{
friend class BoyFriend;
private:
int data;
public:
GirlFriend(int data)
:data(data)
{}
};
class BoyFriend
{
private:
public:
void bedExercise(GirlFriend* girl)
{
cout << __FUNCTION__ << " " << girl->data;
}
};
int main()
{
GirlFriend g(234);
BoyFriend().bedExercise(&g);
return 0;
}
在GirlFriend类中，把BoyFriend类声明为了友元类，此时在BoyFriend类中，就可以随心所欲的访问 GirlFriend类的私有成员了！
注意
友元函数有优点也有缺点，用好了是神器，用坏了是毁灭！
**优点：**能够提高效率，表达简单、清晰
缺点： 友元函数破环了类的封装性，尽量使用成员函数，除非不得已的情况下才使用友元函数
建议：常中用的也不多，用到忘了在查也行
成员指针
下面内容，了解即可，需要实际情况学习，忘了现查也行。
成员变量指针
非静态成员变量指针
定义成员变量指针：
int A::*p = &A::num; // 注意：*p是定义的，在A类中没用被定义
通过成员变量指针访问成员变量：
A a(22);
cout<<" "<<a.*p; // ** 必须 **通过对象去访问
静态成员变量指针
定义静态成员变量指针：
int *p = &A::static_number;
可以通过对象访问
A a(22);
cout<<" "<<a.*p;
// 也可以，直接输出
cout << *p << endl;
成员函数指针（类）
非静态成员函数指针
定义成员函数指针:
void (A:: * pshow)() = &A::show; //对于成员函数来说必须取地址
//A:: show() 这是类的真正原型，在类中只是省略了
通过成员函数指针调用成员函数
//在类外调用 ， 必须通过对象调用
(a.*pshow)(); //必须先实例化对象
//在类内调用
(this->*pshow)();
静态成员函数指针
定义静态成员函数指针：（存在全局区里）
void (* pstatic_show)() = &A::static_show;
不可以通过对象访问
cout<<" "<<(*pstatic_show（）);
也可以直接访问
cout<<" "<<pstatic_show();
- 定义静态成员指针时候，左边都不加 对象:: ，只有定义非静态成员才会加 (A:: *show)() 。但是右边一样，都要加&