C++中成员变量加上static或const关键字后的分析

C++中类成员变量加上static或const关键字后的初始化问题。在一个简单的C++类中定义如下这些变量:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable(){}
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};

int main(){
	TestVariable variable;
	return 0;

}
加入限定符后多了4中情况,下面就这四种情况分别进行分析。

情况1:const修饰

编译上面的代码,首先在情况1处出现问题,在g++中的错误提示是:

技术分享
在vs中的提示更明显,“error C2758: “TestVariable::constIntVariable”: 必须在构造函数基/成员初始值设定项列表中初始化”。直接给出了解决方法,就是说对于类中的const常量类型而言,需要在构造函数初始化化列表中进行初始化

#include <iostream>

using namespace std;

class TestVariable{
public:
	TestVariable()<span style="color:#ff0000;">:constIntVariable(0)</span>{}
private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};

int main(){
	TestVariable variable;
	return 0;

}
这样情况1的问题就解决了。

情况2:static修饰

然后编译上面的代码能通过,不过明显还有问题,就是static变量没有初始化化,但是编译时没有出错。原因就是还没有使用到这些变量,因为static变量是类的所有实例共享的,所以在构造variable这个变量时只对constIntVariable这个变量进行了检查,在编译时会出错,但是其余的3个静态变量由于没有使用所有还看不出问题所在。将代码修改成这样来检查情况2中静态变量的问题:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable():constIntVariable(0){}

	<span style="color:#ff0000;">void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}</span>
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};

int main(){
	TestVariable variable;
	variable.printStaticInt();
	return 0;

}
g++编译时的错误情况如下:

技术分享

vs中的错误提示为“error LNK2001: 无法解析的外部符号 "private: static int TestVariable::staticIntVariable" (?staticIntVariable@TestVariable@@0HA)”,这种情况下g++中的提示更明显些,就是对TestVariable::staticIntVariable这个变量未定义的引用,所以我们的解决方法就是将它初始化。这个变量的初始化这样操作:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable():constIntVariable(0){}

	void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};
<span style="color:#ff0000;">int TestVariable::staticIntVariable=1;</span>
int main(){
	TestVariable variable;
	variable.printStaticInt();
	return 0;

}

注意int TestVariable::staticIntVariable=1;这行代码不能写成static int TestVariable::staticIntVariable=1;,否则就在g++中会出现这个错误:

技术分享

而在vs中会出现“error C2720: “TestVariable::staticIntVariable”: 成员上的“static ”存储类说明符非法”这个错误提示。

情况3:static const修饰的整型数据

然后就是情况3和情况4,情况3和情况4中的限定符是一样的,就是static const(这里写成static const和const static好像都可以,最起码在vs和g++中测试都通过了),不同的是数据类型而已,这里int类型是一种特例,就是静态常量整型(short ,int ,long,long long)数据可以在类中初始化,而其他类型都只能在类外面进行初始化。

首先添加调用这个变量的函数:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable():constIntVariable(0){}

	void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}

	<span style="color:#ff0000;">void printStaticConstInt(){
		cout<<"staticOnstIntVariable:"<<staticConstIntVariable<<endl;
	}</span>
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};
 int TestVariable::staticIntVariable=1;
int main(){
	TestVariable variable;
	variable.printStaticInt();
	variable.printStaticConstInt();
	return 0;

}

在g++中编译的结果为:

技术分享

用vs编译出错:“ error LNK2001: 无法解析的外部符号 "private: static int const TestVariable::staticConstIntVariable" (?staticConstIntVariable@TestVariable@@0HB)”,和情况2的错误提示是一样的。

只是它的定义方式有两种,在类内定义:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable():constIntVariable(0){}

	void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}

	void printStaticConstInt(){
		cout<<"staticOnstIntVariable:"<<staticConstIntVariable<<endl;
	}
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	<span style="color:#ff0000;">static const int staticConstIntVariable=3;//情况3 静态常整型类型</span>
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};
 int TestVariable::staticIntVariable=1;
int main(){
	TestVariable variable;
	variable.printStaticInt();
	variable.printStaticConstInt();
	return 0;

}
在类外面定义:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable():constIntVariable(0){}

	void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}

	void printStaticConstInt(){
		cout<<"staticOnstIntVariable:"<<staticConstIntVariable<<endl;
	}
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};
 int TestVariable::staticIntVariable=1;
<span style="color:#ff0000;"> const int TestVariable::staticConstIntVariable=3;</span>
int main(){
	TestVariable variable;
	variable.printStaticInt();
	variable.printStaticConstInt();
	return 0;

}
注意,这里const这个关键字也需要,否则在g++中会出现这种错误提示:它会把它当成一个新的变量,但这个变量和原来的const类型的变量名相同,所以会出错。

技术分享

在vs中的提示为:“error C2373: “staticConstIntVariable”: 重定义;不同的类型修饰符”。

情况4:static const修饰的非整型数据

然后就是情况4,对于静态常量非整型数据而言,如果在类内进行初始化:

#include <iostream>

using namespace std;

class TestVariable{
	public:
	TestVariable():constIntVariable(0){}

	void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}

	void printStaticConstInt(){
		cout<<"staticOnstIntVariable:"<<staticConstIntVariable<<endl;
	}
	void printStaticConstNotIntVariable(){
		cout<<"staticConstNotIntVariable:"<<staticConstNotIntVariable<<endl;
	}
	private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	<span style="color:#ff0000;">static const float staticConstNotIntVariable=4.0;//情况4 静态非常整型类型</span>
};
 int TestVariable::staticIntVariable=1;
 const int TestVariable::staticConstIntVariable=3;
int main(){
	TestVariable variable;
	variable.printStaticInt();
	variable.printStaticConstInt();
	variable.printStaticNotIntVariable();
	return 0;

}
在g++中没有问题:技术分享

在vs 2008中会出现这个错误“error C2864: “TestVariable::staticConstNotIntVariable”: 只有静态常量整型数据成员才可以在类中初始化”。

所以最好还是不要写这种代码吧。

将变量的初始化放在类外面和情况3一样就可以了:

#include <iostream>

using namespace std;

class TestVariable{
public:
	TestVariable():constIntVariable(0){}

	void printStaticInt(){
		cout<<"staticIntVariable:"<<staticIntVariable<<endl;
	}

	void printStaticConstInt(){
		cout<<"staticOnstIntVariable:"<<staticConstIntVariable<<endl;
	}
	void printStaticConstNotIntVariable(){
		cout<<"staticConstNotIntVariable:"<<staticConstNotIntVariable<<endl;
	}
private:
	int intVariable;//情况0 不加限定符,这个不需要进行讨论
	const int constIntVariable;//情况1 const常量
	static int staticIntVariable;//情况2 静态变量
	static const int staticConstIntVariable;//情况3 静态常整型类型
	static const float staticConstNotIntVariable;//情况4 静态非常整型类型
};
int TestVariable::staticIntVariable=1;
const int TestVariable::staticConstIntVariable=3;
<span style="color:#ff0000;">const float TestVariable::staticConstNotIntVariable=4.0;</span>
int main(){
	TestVariable variable;
	variable.printStaticInt();
	variable.printStaticConstInt();
	variable.printStaticConstNotIntVariable();
	return 0;

}

这种情况在g++中和vs中运行的结果就都是正确的了。


郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。