如何初始化无法访问的模板类的静态成员？
要初始化无法访问的模板类的静态成员，可以使用模板特化来实现。模板特化是指为特定类型的模板参数提供特定的实现。
以下是一种可能的方法：
- 首先，定义一个模板类，并声明一个静态成员变量：template <typename T> class MyClass { public: static T staticMember; };
- 在类外部，使用模板特化来为特定类型的模板参数提供静态成员的定义和初始化：template <> int MyClass<int>::staticMember = 0; template <> std::string MyClass<std::string>::staticMember = "example";
- 在代码中使用该模板类及其静态成员：int main() { std::cout << MyClass<int>::staticMember << std::endl; // 输出：0 std::cout << MyClass<std::string>::staticMember << std::endl; // 输出：example return 0; }
在这个例子中，我们通过模板特化为int和std::string类型的模板参数提供了不同的静态成员定义和初始化。这样，我们就可以通过类名和作用域解析运算符来访问和使用这些静态成员。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云产品：云服务器（https://cloud.tencent.com/product/cvm）
- 腾讯云产品：云数据库 MySQL 版（https://cloud.tencent.com/product/cdb_mysql）
- 腾讯云产品：云原生容器服务（https://cloud.tencent.com/product/tke）
- 腾讯云产品：人工智能（https://cloud.tencent.com/product/ai）
- 腾讯云产品：物联网（https://cloud.tencent.com/product/iotexplorer）
- 腾讯云产品：移动开发（https://cloud.tencent.com/product/mobile）
- 腾讯云产品：对象存储（https://cloud.tencent.com/product/cos）
- 腾讯云产品：区块链（https://cloud.tencent.com/product/baas）
- 腾讯云产品：腾讯云游戏引擎（https://cloud.tencent.com/product/gse）
- 腾讯云产品：腾讯云直播（https://cloud.tencent.com/product/live）
- 腾讯云产品：腾讯云音视频（https://cloud.tencent.com/product/tcav）
- 腾讯云产品：腾讯云智能图像（https://cloud.tencent.com/product/tii）
- 腾讯云产品：腾讯云智能语音（https://cloud.tencent.com/product/tts）
- 腾讯云产品：腾讯云智能文本（https://cloud.tencent.com/product/nlp）
- 腾讯云产品：腾讯云智能机器人（https://cloud.tencent.com/product/tcr）
- 腾讯云产品：腾讯云智能推荐（https://cloud.tencent.com/product/irs）
- 腾讯云产品：腾讯云智能视频（https://cloud.tencent.com/product/tvs）
- 腾讯云产品：腾讯云智能音箱（https://cloud.tencent.com/product/tis）
- 腾讯云产品：腾讯云智能助手（https://cloud.tencent.com/product/tas）
- 腾讯云产品：腾讯云智能翻译（https://cloud.tencent.com/product/tmt）
- 腾讯云产品：腾讯云智能语音合成（https://cloud.tencent.com/product/tts）
- 腾讯云产品：腾讯云智能语音识别（https://cloud.tencent.com/product/asr）
- 腾讯云产品：腾讯云智能语音评测（https://cloud.tencent.com/product/ise）
- 腾讯云产品：腾讯云智能语音唤醒（https://cloud.tencent.com/product/wakeup）
- 腾讯云产品：腾讯云智能语音分析（https://cloud.tencent.com/product/iva）
- 腾讯云产品：腾讯云智能语音词法分析（https://cloud.tencent.com/product/nlp）
- 腾讯云产品：腾讯云智能语音情感分析（https://cloud.tencent.com/product/nlp）
- 腾讯云产品：腾讯云智能语音语义理解（https://cloud.tencent.com/product/nlp）
- 腾讯云产品：腾讯云智能语音语音合成（https://cloud.tencent.com/product/tts）
- 腾讯云产品：腾讯云智能语音语音识别（https://cloud.tencent.com/product/asr）
- 腾讯云产品：腾讯云智能语音语音评测（https://cloud.tencent.com/product/ise）
- 腾讯云产品：腾讯云智能语音语音唤醒（https://cloud.tencent.com/product/wakeup）
- 腾讯云产品：腾讯云智能语音语音分析（https://cloud.tencent.com/product/iva）
- 腾讯云产品：腾讯云智能语音语音词法分析（https://cloud.tencent.com/product/nlp）
- 腾讯云产品：腾讯云智能语音语音情感分析（https://cloud.tencent.com/product/nlp）
- 腾讯云产品：腾讯云智能语音语音语义理解（https://cloud.tencent.com/product/nlp）
请注意，以上链接仅供参考，具体产品选择应根据实际需求和情况进行评估。
相关·内容
1回答
静态成员变量何时优化？
、、、、
编译器为什么以及何时优化静态成员变量？我有以下代码
#include <iostream>
#include <typeinfo>
class X {
public:
X(const char* s) { std::cout << s << "\n"; };
};
template <class S> class Super {
protected:
Super() { (void)m; };
static inline X m { typeid(S).name() };
};
class
浏览 8提问于2022-07-06得票数 6
回答已采纳
4回答
通常，一个类的静态成员/对象对于具有静态成员/对象的类的每个实例都是相同的。无论如何，如果静态对象是模板类的一部分并且还依赖于模板参数，那该怎么办呢？例如，如下所示：
template<class T>
class A{
public:
static myObject<T> obj;
}
如果我将A的一个对象转换为int，另一个转换为float，我猜会有两个obj，每种类型一个。
如果我创建多个A对象作为类型int和多个float，它还会是两个obj实例吗，因为我只使用了两个不同的类型？
浏览 0提问于2010-02-08得票数 14
回答已采纳
当普通类的静态成员的构造函数被调用时，有大量的信息。然而，我看到了一些关于模板类的奇怪行为。
以下程序的输出应该是什么？(注意，我使用printf是为了避免std：：cout的任何静态初始化顺序失败。)
#include <iostream>
class B {
public:
B(const std::string &s) { printf("Hello I am B from %s\n", s.c_str()); }
};
template<typename T>
class Atempl {
public:
static B b
浏览 1提问于2011-08-06得票数 9
回答已采纳
4回答
在给定文件中，如果我有，
struct A { static int a; };
struct B { static int b; };
int A::a;
int B::b;
然后，我总是可以期待在B::b之前初始化A::a。现在对于相同的文件，以template为例，
template<typename T>
struct X { static T t; };
template<typename T>
T X<T>::t;
假设X是用A和B实例化的，并且它的static成员在代码中的某个地方被任意使用，如，X<A>::t和X<B>
浏览 2提问于2011-07-14得票数 7
回答已采纳
1回答
在接下来的课程中，我尽量避免使用虚拟化，看看是否可以挤出更多的性能/内存效率。当我想要实现一个StateManager (coursework prototype是一个小游戏)时，问题就开始了。
为了实现这一点，我有一个模板来“统计”当前State的成员函数调用。
一个示例状态如下：
struct TestState {
bool update(float delta) {
return true;
}
};
现在，状态管理器应该能够接受任何State-Class并绑定更新函数。
从理论上讲，如果State是一个只包含静态函数的类/结构，这将很容易，但这也增加了
浏览 1提问于2012-11-28得票数 1
下面这个案子怎么样？如果存在依赖关系，编译器能正确处理静态变量的初始化顺序吗？
a.h
template<class T>
struct A { static double a; };
template<class T>
double A<T>::a = 1;
b.h
struct B { static double b; };
b.cpp
#include "b.h"
#include "a.h"
double B::b = A<int>::a;
浏览 4提问于2013-09-16得票数 3
回答已采纳
1回答
考虑以下代码
#include <iostream>
using namespace std;
struct Printer{
Printer(){
std::cout << "Created\n";
}
};
template<class Derived>
struct InitPrinter{
static Printer p;
};
template<class Derived>
Printer InitPrinter<Derived>::p;
struct My
浏览 3提问于2013-11-13得票数 3
回答已采纳
1回答
我正在编写一段代码，其中需要使用类模板实例的静态变量初始化某个类的静态成员变量。我知道静态初始化顺序的失败，并发现了关于这个问题的几个讨论，但没有一个真正帮助我解决我的问题。我甚至不知道为什么这对我来说是个问题。
这是一个很小的例子，它再现了我从代码中得到的错误：
#include <string>
#include <map>
template<class T>
class Foo {
private:
static inline std::map<std::string, T> map_ = {};
public:
浏览 4提问于2022-09-16得票数 0
回答已采纳
2回答
请帮助我纠正以下错误。
错误1错误C2248：‘平方矩阵：：平方矩阵’：无法访问类'SquareMatrix‘中声明的私有成员
我试图在类(矩阵)下实现一个子类(方阵)，我不知道如何修复这个错误。这是密码。
#ifndef _MATRIX_
#define _MATRIX_
#include <iostream>
#include <vector>
using namespace std;
//class matrix starts here
template<class T, int m, int n>
class Matrix{
浏览 1提问于2016-04-06得票数 0
回答已采纳
1回答
C++模板静态整数常量:类外定义
、、、、
此问题涉及Visual C++中带有标志/Za的模板与静态积分常量之间的关系。它对boost库有影响。
首先，让我们检查没有模板的代码：
struct easy
{
static const int a = 5;
const int b;
easy( int b_ ) : b( std::max( b_, a ) )
{}
};
const int easy::a;
int main()
{
easy d_Easy( 0 );
return 0;
}
根据的手册页面：“在标准(/Za)下，您必须为数据成员做一个类外定义”。该页面中的示例和
浏览 2提问于2015-01-07得票数 9
回答已采纳
2回答
请考虑以下代码：
template <typename T>
struct Test
{
Test() = default;
explicit Test(const T& arg)
: m_member(arg)
{
}
T m_member{};
};
int main()
{
Test<int> t1;
int v2 = 34;
Test<int&> t2(v2); // (!)
ret
浏览 0提问于2019-09-03得票数 4
回答已采纳
这些表达式都是普通类型的定义：
int num;
bool flag;
但是，一些看起来像普通类型定义的表达式意外地变成了模板的声明(详见下面和)！
下面是相关的代码片段()：
#include<iostream>
template<typename T>
class Test
{
public:
static constexpr int sdm = T(nullptr);
static int f(void){static_assert(sizeof(T)==0);}
int g(
浏览 5提问于2021-01-10得票数 2
回答已采纳
2回答
我正在尝试理解静态数据成员模板的概念。我在一本书中看到了下面的例子：
class Collection {
public:
template<typename T>
static T zero = 0;
};
当我尝试执行时，它给出的错误如下：
undefined reference to `Collection::zero<int>'
为了解决上述错误，我尝试在上面的程序中添加以下代码，但仍然会出现错误：
template<typename T> T Collection::zero = 0; //even a
浏览 8提问于2022-01-25得票数 0
回答已采纳
2回答
据我所知，在任何人尝试使用全局对象之前，都需要调用这些对象的构造函数。然而，在我的程序中，情况似乎并非如此。这里是我的简化代码(我用gcc 4.6.3-1ubuntu5版本编译)
#include <iostream>
using namespace std;
struct type_data
{
int id;
type_data()
: id(-1) // set some invalid id
{
cout << "creating a new type data" << e
浏览 2提问于2013-01-25得票数 0
回答已采纳
1回答
我有两个具有静态成员实例的类的测试用例。前者使用非模板化的示例，而第二个则依赖于一般对象类型。
这个困境很简单:静态成员的构造函数在主函数之前被调用(正如它应该的那样)，但只对特定的对象类型调用。泛型类型不具有相同的行为。事实上，构造函数根本没有编译。看来编译器决定完全忽略它作为优化的一种手段(不是完全正确的)。
我想知道发生了什么事，以及如何才能使它以最优雅的方式运作。我想最明显的答案是:在代码中的某个地方使用静态成员。我不想这样做，因为除了在构造函数中执行一些“工作”之外，特定类型的情况不需要使用静态成员。
代码示例：
///////////////////////////////////
浏览 2提问于2014-02-20得票数 2
回答已采纳
1回答
我正在编写一个多线程的模板矩阵。我需要我的矩阵能够使用这行代码(我不能改变它，这是我的程序的要求)：
Matrix<Complex>::setParallel(false);
因此对于这种并行(这是一个布尔值，决定是否使用多线程)必须是静态的。
所以一开始我是这样定义的：
template<class T>
class Matrix
{
private:
...
public:
static bool parallel;
...
};
但是我得到了这个错误：
... undefined reference to 'Matrix<int>::paral
浏览 0提问于2015-11-16得票数 1
1回答
在这个代码片段中：
template <size_t N>
struct Foo {
static constexpr std::array<char, N> arr{{0}};
static const char *data() { return &arr[0]; }
};
template<>
constexpr std::array<char, 5> Foo<5>::arr;
int main()
{
std::cout << Foo<5>::data() <<
浏览 1提问于2015-10-24得票数 12
回答已采纳
我知道不同翻译单位的静态变量的初始化顺序问题。然而，我的问题是在一个翻译单位内，实际上，在一个结构内：
template <int size>
struct SlidingTile {
using AllActions = std::array<int, size>;
using AllMDDeltas = std::array<int, size>;
int mdDelta(int i) const {
return mdDeltas_[i];
}
static AllActions comput
浏览 1提问于2017-02-13得票数 5
回答已采纳
可能重复：
编辑:有一个副本，但我会放弃这个，因为我个人有困难找到它。此外，以下是帮助我的答案：
假设有以下类：
template<class X>
struct A
{
static bool x;
static bool foo()
{
cout << "here";
return true;
}
};
template<class X>
bool A<X>::x = A<X>::foo();
我会假设当我专门处理A时，静态字段x会被初始化。然而，下列各点
浏览 2提问于2012-04-26得票数 6
回答已采纳
如果没有使用静态成员，则是否在模板类中初始化静态成员变量？我用它来注册类型。
template<class T>
class A
{
static bool d;
};
template<class T> bool A<T>::d = [](){regist<A<T>>(); return true;}();
int main()
{
A<int> a;
return 0;
}
我找到一种方法来测试它。它打印1，而不是2。regist()不是名为abd，静态成员没有初始化。我的测试在VC110编译器
浏览 2提问于2013-10-13得票数 3
2回答
template <typename T>
struct A
{
static constexpr T obj {};
static constexpr bool noexcept_copy = noexcept( T{obj} );
static void UsesCopy() { T{obj}; }
static constexpr int C = 1;
};
struct NoCopy
{
constexpr NoCopy() = default;
NoCopy(const NoCopy&) = delete;
浏览 1提问于2019-08-22得票数 21
回答已采纳
4回答
模板类的静态变量初始化，c++
、、、、
考虑以下代码：
//header.h
template<class T>
class A
{
static int x;
};
template<class T>
int A<T>::x = 0;
//source1.cpp
#include "header.h"
void f(){} // dummy function
//main.cpp
#include "header.h"
int main(){}
在本例中，代码编译完美，没有错误，但如果我从类中删除模板限定符
class A
{
static
浏览 10提问于2015-04-27得票数 1
回答已采纳
给予：
template<class T>
struct S {
static int const N = 1;
};
extern template class S<int>;
template<class T>
int f( T n ) {
return n + S<T>::N; // line 10
}
int main() {
return f(1); // line 14
}
//template class S<int>; // intentionally commented out to
浏览 8提问于2011-02-17得票数 3
1回答
在C++中，除了以下例外情况外，类主体中的static成员可能不会被初始化：
static成员的const积分型可以 be
static成员的constexpr文字类型必须 be
你能解释一下为什么会有这些例外吗？
此外，这也适用于：
即使在类主体中初始化了const static数据成员，通常也应该在类定义之外定义该成员。
我一点也不明白这一点。这个额外的定义有什么意义？
只是想从这里得到一些直觉。
浏览 2提问于2013-05-04得票数 16
回答已采纳
让我们举个例子：
template<typename T> struct foo
{
template<typename X> void bar(void (T::*)()) {}
template<typename X> void bar(X*) {}
template<typename X> void bar(T**) {}
};
int main() { foo<int> p; }
上面的class foo<int>实例化会不会实例化成员模板声明 bar，即使成员本身就是模板？如有任何标准参
浏览 1提问于2016-01-19得票数 2
回答已采纳
3回答
我正在尝试创建一个类，其中包含一个模板对象成员。例如
mt_queue_c<int> m_serial_q("string");
但是，当我这样做时，它无法编译。如果我将这一行移到类定义的之外以使它成为全局对象，那么它就编译得很好。
我将代码浓缩为尽可能小的失败单元，如下所示(是的，这是没有意义的，因为其他成员变量和函数都丢失了.)
#include <deque>
#include <queue>
#include <pthread.h>
#include <string>
#include <iostr
浏览 2提问于2010-07-13得票数 1
回答已采纳
3回答
静态初始化是很好的描述主题，，甚至在这个站点。
在任何地方，如果存在不同的编译单元和相关的静态变量，就会出现这样的问题。如果静态变量存在于一个编译单元中，就不会出现问题:它们将按照它们在文件中的位置进行初始化。
但我有个密码：
template <typename T>
class A{
public:
int _data;
T _obj;
A(int data) :_data(data){}
};
template <typename T>
class B{
public:
const static B<T> nullOb
浏览 2提问于2014-08-27得票数 5
回答已采纳
我只想问一下，为什么MSVS2013会抱怨这个代码，而不是GCC(至少4.8.3)：
template <typename T>
struct MyClass
{
typedef std::function<T*()> FunctionType;
static FunctionType funcObj;
};
template <typename T> typename MyClass<T>::FunctionType MyClass<T>::funcObj =
[]{return new T();};
在m
浏览 0提问于2014-12-20得票数 3
回答已采纳
1回答
背景
我们试图“借用”一些使用内联静态变量的代码。该代码不带任何警告，符合C++17编译器。但是，对于较低版本的编译器，它会发出以下警告：
warning: inline variables are only available with ‘-std=c++17’ or ‘-std=gnu++17’
我们已经能够通过命令行开关来抑制衰退，但是我想知道是否有一种方法可以重构代码来抑制警告。
我已经能够用下面的示例代码重现这个问题：
示例代码
#include <iostream>
using namespace std;
template <typename T>
c
浏览 4提问于2021-11-21得票数 0
1回答
类模板的静态成员是否隐式实例化？
、、、、
考虑以下两个引号：
[C++11: 14.7.1/1]: ..类模板专门化的隐式实例化导致类成员函数、成员类、作用域成员枚举、静态数据成员和成员模板的声明(而不是定义或默认参数)的的隐式实例化；
[C++11: 14.7.1/8]: 类模板的隐式实例化不会导致该类的任何静态数据成员被隐式实例化.
(还分别在[C++14: 14.7.1/1]和[C++14: 14.7.1/9]中找到逐字(除了对异常规范的新引用外)
我在这里错过了什么？隐式实例化类模板和隐式实例化类模板专门化之间有什么区别？这两句话怎么能不冲突呢？
类模板专门化如果类类型在需要完全定义的对象类型的上下文中使用，或者类类
浏览 0提问于2014-10-31得票数 4
回答已采纳
// gamewindow.hpp
#include <SFML/Graphics.hpp>
#include <string>
#include <cstdint>
class GameWindow : public sf::RenderWindow
{
public:
GameWindow(const uint32_t&, const uint32_t&, const std::string&);
void toggleFullscreen();
static const ResolutionSett
浏览 0提问于2017-04-04得票数 1
回答已采纳
2回答
static_cast<the_template<int>*>(0) -这个用int类型实例化the_template吗？
问这个问题的原因是下面的代码，它会在链接到Clang和GCC 4.4.5的未定义的check_error<char>(void*, long)引用时出错，这表明它没有实例化模板。不过，MSVC和编译和链接都很好，这使得人们相信它确实实例化了模板。但是，如果忽略强制转换，MSVC和GCC ( 4.4.5和4.5.1)只会在check_error<char>上出错(被通缉的行为)，而Clang则会在这两个调用上出错。通常情况下，
浏览 3提问于2011-12-04得票数 29
回答已采纳
2回答
#include <iostream>
class Temp {
public:
static Temp temp;
Temp() { std::cout << "hi!"; }
};
int main() {}
令人惊讶的是，"hi“没有打印出来。我检查了程序集，它省略了temp的构造。
确保静态类成员的构造函数被正确调用的条件是什么？
其他问题：
为什么模板化类的行为会有所不同？
#include <iostream>
template <typename T>
class Temp {
publ
浏览 0提问于2020-12-23得票数 2
1回答
我正在尝试以下几点..。
#include <iostream>
using namespace std;
template<class T>
class Singleton
{
private:
class InstPtr
{
public:
InstPtr() : m_ptr(0) {}
~InstPtr() { delete m_ptr; }
T* get() { return m_ptr; }
void set(T* p)
{
if
浏览 4提问于2021-08-02得票数 1
回答已采纳
在下面的库代码中：
#include <cmath>
namespace blah {
const double pi=4.0*std::atan(1.0);
}
template <int I>
class ClassB
{
public:
ClassB() {myval = blah::pi;}
private:
double myval;
};
template <int I>
class ClassA
{
public:
static ClassB<I> b;
};
template<int I>
C
浏览 8提问于2015-02-26得票数 2
3回答
在非模板化的库类中拥有静态成员的最好方法是什么，而不是将定义成员的负担放在类user上？
假设我想提供这个类：
class i_want_a_static_member
{
static expensive_resource static_resource_;
public:
void foo()
{
static_resource_.bar();
}
};
然后，类的用户一定不要忘记在某个地方定义静态成员(已经在 中定义了)：
// this must be done somewhere in a translation unit
expe
浏览 7提问于2012-07-29得票数 55
回答已采纳
2回答
在下面的代码中，我正在寻找一个可移植的单行替换#define。替换应该将单词APPLE隐藏在Foo对象的命名空间中。
class Foo {
public:
#define APPLE 123
Foo(int a) : a_(a) { }
};
// elsewhere in another file
Foo f(APPLE);
我试着让它更友好一些，并且使用Intel 2017编译器进行了工作：
class Foo {
public:
static constexpr int APPLE = 123;
Foo(int a) : a_(a) { }
};
浏览 0提问于2018-10-18得票数 4
3回答
自动销毁静态对象
、、
为什么C++不创建/销毁模板类型的静态成员。
观察以下示例：
#include <iostream>
struct Dump {
Dump() {
std::cout << "CTOR" << std::endl;
}
~Dump() {
std::cout << "DTOR" << std::endl;
}
};
template <typename T> struct X {
static Dump dump;
};
template <t
浏览 2提问于2011-09-22得票数 7
回答已采纳
2回答
静态初始化的非文字对象的销毁顺序
、、、、
一个让我注意到的方式。新特性是，具有静态存储持续时间的非局部变量可以在静态初始化阶段初始化，如果其初始化器由constexpr构造函数组成，即使变量的类型不是文字类型。更确切地说，basic.start.init中的新措辞是：
对象o的常量初始化器是一个常量表达式，但它也可以调用o及其子对象的constexpr构造函数，即使这些对象是非文字类类型的。注意:此类类可能有一个非平凡的析构函数尾注。执行常量初始化..。如果具有静态或线程存储持续时间的对象被构造函数调用初始化，如果初始化完整表达式是对象的常量初始化器，则.
典型的例子是std::unique_ptr，它“不应该比手写的更糟”：
浏览 2提问于2014-11-29得票数 11
2回答
当我链接包含静态对象的文件时，将运行该对象的构造函数，而不管该对象是否曾经被使用过，甚至还包括了标头。在g++中是否有一种方法来阻止这种行为的发生，或者仅仅是不链接文件的唯一答案？
foo.h
#include <iostream>
class Bar {
public:
Bar(int inMemberInt) {
std::cout << "In Bar constructor." << std::endl;
}
};
class Foo {
public:
static const Bar c
浏览 1提问于2020-02-18得票数 0
回答已采纳
1回答
我对C++相当缺乏经验，我正在努力理解这段代码的作用。
template <typename T>
class System : public BaseSystem
{
[..]
private:
static SystemType sysType;
};
在类定义之外，有如下内容：
template <typename T>
SystemType System<T>::sysType= IDGen<BaseSystem>::GenerateNextID();
这是否将sysType类中的System字段设置为新ID？但是既然sysType字段
浏览 0提问于2015-01-30得票数 3
回答已采纳
我的c++书(lippman，c++引物，第五版，第508页)提供了以下4条规则，用于计算编译器何时将复制控制和默认构造函数合成为已删除的成员：
如果类的成员自己的析构函数被删除或无法访问(例如，私有)，则合成析构函数被定义为已删除。
如果类的成员自己的副本构造函数被删除或无法访问，则合成复制构造函数被定义为已删除。如果类的成员具有已删除或不可访问的析构函数，则也会删除。
如果成员具有已删除或不可访问的复制赋值操作符，或者类具有const或引用成员，则合成复制赋值操作符被定义为已删除。
如果类的成员具有已删除或不可访问的析构函数，或者具有没有类内
浏览 4提问于2013-01-28得票数 1
回答已采纳
2回答
前几天我遇到了一些意想不到的行为，并将其简化为以下几行代码。我在VC++ 19.0、clang3.8、GCC 5.4.0和8.2.0上进行了测试。每种情况下的输出都是1，而我原本希望它在Hello之前，在Goodbye之前。
#include <iostream>
template <class T> struct X { static T data; };
template <class T> T X<T>::data;
struct A
{
A()
{
std::cout << "Hel
浏览 0提问于2018-08-11得票数 1
3回答
专用模板类的静态成员初始化
、、、、
class A
{
};
template <typename A, int S>
class B
{
public:
static int a[S];
B()
{
a[0] = 0;
}
};
template<> int B<A, 1>::a[1];
int main()
{
B<A, 1> t;
t;
}
在GCC 4.1下编译，但不链接：
static.cpp:(.text._ZN1BI1ALi1EEC1
浏览 0提问于2010-02-26得票数 18
2回答
为什么下面的代码会引发异常(在createObjects调用map::at中)--可以交替地查看代码(及其输出)
此外，如果注释行在微软和gcc编译器中都没有注释(请参阅)，代码就会像预期的那样工作，这甚至可以将initMap作为普通的静态变量，而不是静态的getter。
我能想到的唯一原因是静态registerHelper_对象(factory_helper_)和std::map对象(initMap)的初始化顺序是错误的，但是我看不出这是怎么发生的，因为映射对象是在第一次使用的基础上构造的，在factory_helper_构造函数中，所以一切都应该是正常的，不是吗？更让我感到惊讶的是，这些d
浏览 1提问于2010-05-17得票数 4
回答已采纳
2回答
ios_base类中的静态常量是在创建时初始化的，这对常量很有意义。非常量静态成员变量是否可以用同样的方式初始化，或者这个概念是否只允许常量静态成员使用？
对于带有gnu的非常量静态成员，编译器必须使用总是定义/分配空间，而不是在头文件中减速？以这种方式初始化常量静态成员合适吗？
浏览 2提问于2011-04-23得票数 1
回答已采纳
对于ex。我得到："wrapper.h“
class wrapper : public QWidget
{
Q_OBJECT
public:
Wrapped_class m_class;
private:
QTimer* m_timer;
}
"Wrapped_class.h“
class Wrapped_class
{
public:
Wrapped_class();
public slots:
f(); // slot which is called when m_timer send signal timeout()
}
浏览 0提问于2012-08-16得票数 0
回答已采纳
下面是我要编译的代码：
F.h：
#include <limits>
template <typename T> class STreeNode {
public:
T key;
STreeNode<T>* child[2];
STreeNode( const T& k ) :
key(k), child{ nullptr, nullptr } {};
};
template <typename T>
class STree {
STreeNode<T> *root;
浏览 5提问于2013-12-04得票数 0
回答已采纳
我在这里有一个问题，所以，为什么(为什么？)在类中初始化静态变量是不可能的？我所做的
如果一个非易失性的非内联静态数据成员是整数或枚举类型的，那么如果程序中使用了odr，那么.仍然应该在名称空间作用域中定义，并且命名空间范围定义不应该包含初始化器。
所以，像这样的例子
struct X {
static int const n = 7; // should be defined outside the class,
// but it's compiles successfully
};
我看到这个话题，就给出
浏览 0提问于2019-03-19得票数 5
回答已采纳
让我们想象一下，我声明了一个模板结构：
template <int N> struct mystruct;
让我们想象一下，我的结构对于所有的N都有一个通用的行为，除了N == 0
例如，我可以通过以下方式声明N == 0的特殊行为：
template<> struct mystruct<0> {int k = 0};
我还可以在以下几个方面宣布一般行为：
template<int N> struct mystruct {float k = 3.14;};
如果我主要的话：
struct mystruct<-1> x;
struct
浏览 1提问于2018-02-13得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
