[C++知识库]作用域为类的常量 | 类的静态成员

有时候我们希望在类中，拥有一个常量，该常量对于所以对象均为相同的值
比如：
在类中设置大小为 10 的数组：
我们可以想到 宏定义 或者 使用 const 常量

#define MAX_SIZE 10
const int MAX_SIZE 10

但我们定义的这些变量的作用域均为全局的，我们想要将它的作用域局限在类中，该怎么办呢？

想一想，这样可以吗？

#include<iostream>
using namespace std;
/*
* 在类中想创建常量对于所有对象都是相同的 
*/
class Person{ // class declaration
	  private:
 	  const int SIZE=10; //error  this is not a declaration 
 	  //这是一个初始化 
	  	int num[SIZE];//编译器不知道SIZE为多少
};
//声明类只是描述对象的形式，并没有创建对象 
int main(){
	
	return 0;
} 

我们既然不能在类中初始化（在c++11 中 可以对数据成员初始化，除了数组）
那我们可以借用初始化列表啊！
比如代码：

#include<iostream>
using namespace std;
/*
* 在类中想创建 常量对于所有对象都是相同的 
*/
class Person{
public:
	 Person(int size);
 	const int SIZE;//不直接初始化了，采用构造函数初始化
	  	
}; 
int main(){
   Person p1(10);
   Person p2(11);
	  cout<<p1.SIZE<<endl;//SIZE = 10 ，常量
	  cout<<p2.SIZE<<endl; //SIZE =11 ， 常量
			// 很明显 这个不是所有对象都有一个相同的常量
	return 0;
} 
Person::Person(int size):SIZE(size){ };

这种方法不同的对象会有不同的常量

看来这样子不行，就不卖关子了，
c++有两种方式实现这样的操作
1,在类中声明一个枚举

#include<iostream>
using namespace std;
/*
* 在类中想创建 常量对于所有对象都是相同的 
*/
class Person{
private:
 	enum {SIZE=10}; //作用域为整个类 
	  	int num[SIZE];//编译期间会得到SIZE 的值
}; 
int main(){
	 
	return 0;
} 

2，使用修饰符static 完成：

#include<iostream>
using namespace std;
/*
* 在类中想创建 常量对于所有对象都是相同的 
*/
class Person{
private:
 	 static const int SIZE=10; // 所有Person 对象共享 SIZE 
 	 // mind : 静态变量存储在静态区，不是存储在对象中
	  	int num[SIZE];
}; 
int main(){
	
	return 0;
} 

类的静态成员

特点： 有时候我们希望在类中，拥有一个常量，该常量对于所以对象均为相同的值

我们可以在成员的声明之前加上关键字 static 使其与类关联在一起，这就完成的静态成员的声明

比如我们声明一个表示银行的账号记录：

#include<iostream>
#include <string>

class Account {
public:
   // 构造函数
	Account() = default;  
	Account(const std::string &s, double amt):
		owner(s), amount(amt) { }

    void calculate() { amount += amount * interestRate; }
    double balance() { return amount; }
public:
    static double rate() { return interestRate; }
    static void rate(double);   
private:
    std::string owner; 
    double amount = 0.0;
    static double interestRate; 
    static double initRate() { return .0225; }
    static const std::string accountType;
    static constexpr int period = 30;// period is a constant expression
    double daily_tbl[period];
};

类的静态成员存在与对象之外，对象中不包含任何与静态数据成员有关的数据，静态成员被对象们所共享。
另外静态成员函数不能包含 this 指针，不能声明为const 函数，不能在函数体使用 this 指针

#include<iostream>
using namespace std;
class A {
	 private :
	 	static int value ;
	 	int num;
	 	public :
	 	static int  Get_val()
{
   return this->value; //error  静态函体内不能使用this 指针 
}
}; 
int main(){
  
	return 0;
} 

#include<iostream>
using namespace std;
class A {
	 private :
	 	static int value ;
	 	
	 	int num;
	 	public :
	 	static int  Get_val()const {// error ,static member function cannot have cv-qualifier / const ,volatile 
	 			 return value; 
	 			}
}; 
int main(){
  
	return 0;
} 

现在开始访问数据成员
1 ，我们可以使用作用域解析运算符直接访问静态成员
2，我们也可以使用对象，或对象的引用，或指向对象的指针来访问静态成员

double r; //double; 变量
Account ac1; //一个对象
Account *act2=&act1;//一个指向act1的指针，类型为 Account

r=Account::rate();// 使用作用域解析运算符调用
r=ac1.rate();//使用对象，或者对象的引用调用
r=act2->rate();//使用指向Account对象的指针调用

成员函数体内部可以直接使用静态成员变量，注意:静态成员函数体内部不可以出现非静态成员

我们已经知道类的声明与类的定义是分开的，这就是封装技巧，利于程序的维护。那当然我们是可以将静态成员函数在类的外部定义的；
请看程序：

void Account::rate(double newRate) // 若在void 前加上 static //error， 
//cannot declare member function 'static void Account::rate(double)' to have static linkage 
{
    interestRate = newRate; 
}

当我们在外部定义静态函数时，必须标明函数所属的类名，并且static 只会出现在类的声明里

我们可以为静态成员提供const整形 的类内初始值，
也可以在外部定义静态成员函数。

ok,这次博客就到这里了。