C++知识点 Static

Static

不考虑类的情况

• 静态局部变量/全局变量：用于函数体的内部修饰变量，这种变量的生存期长于该函数。

  1、内存分布
  2、初始化次数，初始化位置。
  3、作用域

  4、静态全局变量的作用：文件隔离

static int i = 1;  //note:3  		 作用域：只在本文件可见  
//int i = 1;  //note:4 
int foo()
{
    static int i = 1; // note:1		 作用域：只在本函数可见  
	//int i = 1;  // note:2
	i += 1;
	return i;
}

//内存分布：全局数据区（静态区）：全局变量与静态变量的存储是放在一起的，初始化的全局变量与静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域，程序结束释放

//第二个问题就浮出水面了，他是在第一次调用进入note：1的时候初始化，且只会初始化一次，也就是第二次调用否f（）的时候不会继续初始化，而会直接跳过。
//静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0（局部变量不会被初始化）

/**
全局变量 可通过 extern int i，可实现跨文件访问；
而静态全局变量	可实现文件隔离
*/

考虑类的情况

• static成员变量、static成员变量。

• 作用一：实现多个对象之间的数据共享与隐藏。

• 作用二：统计实例化对象个数

• 作用三：单例模式

  1.静态成员数据：用于修饰class的数据成员，即所谓的静态成员，这种数据成员的生存期大于class的对象（实体instance）。静态数据成员是每个class有一份,普通数据成员是每个instance有一份，因此静态数据成员也叫作类变量，而普通数据成员也叫作实例变量。

  • 类外初始化，初始化时不需要标明static
  • 定义时需要分配空间
  • 可以被非静态成员函数访问

  2.静态成员函数：用于修饰class的成员函数。

  • 不具有this指针
  • 不能声明为const、虚函数和volatile;
  • 静态成员函数不能访问非静态(包括成员函数和数据成员)，但是非静态成员函数可以访问静态变量和静态成员函数。
  • 调用静态成员函数，可以用成员访问操作符（.）和（->）为一个类的对象或指向类对象的指针调用静态成员函数，也可以使用类名：：函数名调用（因为他本身属于类，用类名调用很正常）

  解释：
  因为静态是属于类的，它是不知道你创建了10个还是100个对象，所以它对你对象的函数或者数据是一无所知的，所以它没办法调用，而反过来，你创建的对象是对类一清二楚的(不然你怎么从它那里实例化呢)，所以你是可以调用类函数和类成员的。

#include<iostream>
using namespace std;
class Rectangle
{
private:
	int m_w,m_h;
	static int s_sum;	
public:
	Rectangle(int w,int h)
	{
		this->m_w = w;
		this->m_h = h;
		s_sum += (this->m_w * this->m_h);
	} 
	static void GetSum()  //这里加上static
	{
		cout<<"sum = "<<s_sum<<endl;
	} 
};

int Rectangle::s_sum = 0;  //初始化

int main()
{
	cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;
	Rectangle *rect1 = new Rectangle(3,4);
	rect1->GetSum();
	cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;
	Rectangle rect2(2,3);
	rect2.GetSum();       //可以用对象名.函数名访问
	cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;
	Rectangle::GetSum();  //也可以可以用类名::函数名访问
	system("pause");
	return 0;
}

作用二：统计实例化个数

#include <iostream>


using namespace std;
class Data
{
    public:
    Data()
    {
        cout<<"无参构造"<<endl;
        count++;
    }
    Data(const Data &ob)
    {
        cout<<"拷贝构造函数"<<endl;
        count++;
	}

    ~Data()
    {
    count--;
    cout<<"析构函数"<<endl;
    }
    
	static int count;
};


int Data::count = 0;


int main(int argc, char *argv[])
{
    Data ob1;
    Data ob2;
    {
    Data ob3;
    Data ob4;
    cout<<"对象的个数:"<<Data::count<<endl;
    }
    cout<<"对象的个数:"<<Data::count<<endl;
    return 0;
}

返回结果

无参构造
无参构造
无参构造
无参构造
对象的个数:4
析构函数
析构函数
对象的个数:2

作用三：单例模式（打印机案例）

步骤1：在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例
步骤2：提供一个公共静态的方法，让客户可以访问它的唯一实例。
步骤3：为了防止在外部对实例化其他对象，将其默认构造函数和拷贝构造函数设计为私有

#include <iostream>
using namespace std;
class Printer
{
public:
	//提供一个方法 获得单例指针
	static Printer* getSignlePrint(void)
	{
		return signlePrint;
	}


	//设置功能函数(自定义)
	void printText(char *str)
	{
		cout << "打印" << str << endl;
		count++;
	}
	int count;
private:
	//1、定义一个静态的 对象指针变量 保存唯一实例地址
	static Printer *signlePrint;
private:
	//2、防止 该类实例化其他对象 将构造函数全部 私有
	Printer() { count = 0; }
	Printer(const Printer &ob) {}


};

Printer* Printer::signlePrint = new Printer;

int main(int argc, char *argv[])
{
	//打印任务1
	Printer *p1 = Printer::getSignlePrint();
	p1->printText("入职报告1");
	p1->printText("体检报告2");
	p1->printText("离职证明3");


	//打印任务2
	Printer *p2 = Printer::getSignlePrint();
	p2->printText("入职报告1");
	p2->printText("体检报告2");
	p2->printText("离职证明3");


	cout << "打印任务数量:" << p2->count << endl;
	system("pause");
	return 0;
}

输出结果

打印入职报告1
打印体检报告2
打印离职证明3
打印入职报告1
打印体检报告2
打印离职证明3
打印任务数量:6