thread_local静态成员模板定义:初始化失败，返回gcc
thread_local是C++11引入的关键字，用于定义线程局部存储（Thread Local Storage，TLS）。它可以修饰静态成员变量，使得每个线程都拥有一份独立的变量副本，各个线程之间互不干扰。
静态成员模板是指在类模板中定义的静态成员函数或静态成员变量，可以根据不同的模板参数生成不同的实例。
初始化失败是指在初始化thread_local静态成员模板时出现异常或错误，导致初始化过程无法完成。
返回gcc是指在初始化失败时，返回的错误信息或错误码，这与具体的编译器和环境有关。gcc是GNU Compiler Collection的缩写，是一种常用的开源C/C++编译器。
需要注意的是，thread_local静态成员模板定义的初始化失败并不会抛出异常，而是返回一个默认值或者未定义的值，具体取决于编译器和环境。
关于thread_local的应用场景，它常用于多线程编程中，可以实现线程安全的全局变量。例如，在多线程服务器程序中，可以使用thread_local修饰一个静态成员变量，用于记录每个线程的连接数或请求计数等信息，以避免线程间的竞争条件。
腾讯云提供了一系列与云计算相关的产品，其中包括云服务器、云数据库、云存储、人工智能等。具体针对thread_local静态成员模板定义初始化失败的问题，腾讯云没有特定的产品或服务与之直接相关。
更多关于thread_local的详细信息，可以参考C++官方文档：thread_local (C++)
相关·内容
1回答
如果表达式的类型不依赖，但我们使用它初始化静态自动变量，那么应该发生什么情况？GCC和克郎的行为各不相同
template<typename T>
struct A {
static inline auto x = sizeof(T{}.f);
};
A<int> a;
GCC没有提出任何错误。但是Clang认为这是无效的，因为它实例化了“sizeof of”的操作数。GCC似乎跳过了这一步，因为sizeof(T{}.f)总是有类型size_t (不依赖于类型)，因此它已经知道x的类型，而不需要实例化。如果我们引用x (例如(void) a.x; )，两个编译器
浏览 5提问于2017-11-09得票数 5
这个项目：
#include <iostream>
struct Foo {
Foo() {
std::cout << "Foo()\n";
}
~Foo() {
std::cout << "~Foo()\n";
}
};
struct Bar {
Bar() {
std::cout << "Bar()\n";
}
~Bar() {
std::cout << &
浏览 8提问于2016-06-30得票数 15
回答已采纳
1回答
我正面临着thread_local的一些奇怪的行为，我不知道我是做错了什么，还是GCC的错误。我有以下最小的复制场景：
#include <iostream>
using namespace std;
struct bar {
struct foo {
foo () {
cerr << "foo" << endl;
}
int i = 42;
};
static thread_local foo FOO;
};
static thread_
浏览 2提问于2014-03-28得票数 7
回答已采纳
1回答
class C {
auto (*foo)() -> decltype(this);
};
此代码为GCC、MSVC和clang所接受，但未被icc接受。
浏览 2提问于2017-11-07得票数 11
回答已采纳
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
回答已采纳
2回答
看起来编译器接受不同的语法来初始化模板中的静态。
template <typename T> struct TBase
{
static const int i;
static const int j;
};
// compile: gcc + clang + visual + icc
template <> const int TBase<double>::i=1;
// compile: vc + icc
// failed gcc, gcc -fpermissive, clang
const int TBase<doub
浏览 3提问于2016-08-10得票数 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回答
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
回答已采纳
这是我的密码。
如果我不评论// typedef auto getFoo1() -> decltype(*this);，这个程序可以在gcc身上运行，但是它在clang ()上编译失败。
class Foo {
public:
// not work on clang but work on gcc
// typedef auto getFoo1() -> decltype(*this);
auto getFoo2() -> decltype(*this);
};
int main() {
Foo f;
return 0
浏览 10提问于2022-08-23得票数 1
回答已采纳
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
回答已采纳
1回答
考虑以下MCVE代码：
struct Id { static inline int id(int c) {return c;} };
template <class C>
class Foo {
C m_bar;
public:
Foo() = default;
Foo(int) : m_bar{bar} {} // Fails in clang, compiles in gcc/msvc
Foo(int, int) : m_bar(bar) {} // Compiles with all gcc/clang/msvc
Foo(int, i
浏览 0提问于2021-08-12得票数 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
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
回答已采纳
下面的代码在c++14中不能在gcc和clang下编译，但是在c++1z中成功了：
struct Cls {
static constexpr int N = 0;
};
constexpr int Cls::N;
constexpr int Cls::N;
C++14错误是可预测的：redefinition of ‘constexpr const int Cls::N’
是什么让这件事变得合法？我发现：
n4659 10.1.5 dcl.constexpr
用constexpr说明符声明的函数或静态数据成员是隐式的内联函数或变量。
因此，我认为这可能与内联变量有关，但在这两种编译
浏览 3提问于2017-07-10得票数 15
回答已采纳
这段代码在MSVC中运行良好，但是根据gcc-4.7.2 C++11的说法，链接器遇到了以下问题。它有什么问题？
错误：
/home/r7Qecv/ccEZjv1w.o: In function `main':
prog.cpp:(.text.startup+0xa): undefined reference to `Foo<long>::s'
prog.cpp:(.text.startup+0x17): undefined reference to `Foo<int>::s'
prog.cpp:(.text.startup+0x2c): un
浏览 0提问于2013-04-16得票数 1
回答已采纳
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
回答已采纳
2回答
struct Value {
using a_type = int;
a_type f() { return 1; }
};
template<typename T>
struct Wrapper {
T t;
auto call_f() { return t.f(); }
};
int main() {
Wrapper<Value> w;
Wrapper<int> w2;
w.call_f();
}
这是很好的关于Clang和GCC的。Wrapper<int>被实例化，即使不能推断Wr
浏览 5提问于2016-08-08得票数 4
回答已采纳
考虑以下代码：
template<typename T>
struct S { static constexpr int bar = T::foo; };
struct U: S<U> { static constexpr int foo = 42; };
int main() { }
编译它，用错误拒绝它：
2:错误:在“U”中没有名为“foo”的成员
结构S{静态常数int bar = T::foo；}；
哪个编译器是对的？
这是否是因为U 在我们试图在S中使用它的时候
在这种情况下，它应该被认为是GCC的错误，但我想知道我是否在之前搜索/打开一个问题的
浏览 7提问于2016-06-14得票数 16
回答已采纳
2回答
为什么下面的代码会引发异常(在createObjects调用map::at中)--可以交替地查看代码(及其输出)
此外，如果注释行在微软和gcc编译器中都没有注释(请参阅)，代码就会像预期的那样工作，这甚至可以将initMap作为普通的静态变量，而不是静态的getter。
我能想到的唯一原因是静态registerHelper_对象(factory_helper_)和std::map对象(initMap)的初始化顺序是错误的，但是我看不出这是怎么发生的，因为映射对象是在第一次使用的基础上构造的，在factory_helper_构造函数中，所以一切都应该是正常的，不是吗？更让我感到惊讶的是，这些d
浏览 1提问于2010-05-17得票数 4
回答已采纳
当普通类的静态成员的构造函数被调用时，有大量的信息。然而，我看到了一些关于模板类的奇怪行为。
以下程序的输出应该是什么？(注意，我使用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
回答已采纳
1回答
我编写了源代码，如下所示。-取样-h
#include <iostream>
template <typename T>
class Sample {
private:
static int foo;
public:
Sample (T number) {
foo = number;}
void display () {
std :: cout << foo << std :: endl;}
};
- test.cpp
#include "sample.h"
template <> int Sample <
浏览 0提问于2017-11-22得票数 0
我只想问一下，为什么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回答
当使用requires子句的类模板的成员在类之外定义时，如果没有指定requires，则gcc不会抱怨，而clang会抱怨。
考虑下面的代码片段：
#include <concepts>
template<typename Container>
requires std::integral<typename Container::value_type>
class Foo {
public:
void func();
};
template<typename Container>
void Foo<Container&g
浏览 11提问于2020-08-28得票数 6
回答已采纳
1回答
非本地线程存储持续时间对象是否在C中初始化为0？
static thread_local int x; // is x initialized to 0?
C17标准如下(在6.2.4.4中)。
是一个对象，其标识符是用存储类说明符_Thread_local声明的，它具有线程存储持续时间。它的生存期是为其创建线程的整个执行过程，并在线程启动时初始化其存储的值。
它没有显式地表示它被初始化为0。但C++标准将其显式化，并指出：(在3.6.2.2中)
在进行任何其他初始化之前，具有静态存储持续时间(basic.stc.static)或线程存储持续时间(basic.stc.thread)的basi
浏览 8提问于2022-03-24得票数 2
回答已采纳
下面是我要创建的池对象的一个最小工作示例(显然不是功能完成--我只是想说明我遇到的问题)
我有一个类模板Storage，它包含aligned_storage
template<typename T, std::size_t N>
struct Storage
{
std::aligned_storage_t<sizeof(T), alignof(T)> data[N];
};
然后，我有一个基类模板PoolObj，它使用operator new从模板参数T的静态类成员中分配。
template<typename T>
struct PoolObj
{
浏览 0提问于2017-11-23得票数 2
回答已采纳
在我的C++类zyBooks的联机模块中，静态数据成员定义为：
关键字静态表示在程序执行期间只在内存中分配一次变量。静态变量驻留在程序的静态内存区域中，并且具有全局范围。因此，静态变量可以从程序中的任何地方访问。
在类中，静态数据成员是类的数据成员，而不是每个类对象的数据成员。因此，静态数据成员独立于任何类对象，可以在不创建类对象的情况下访问。
在下面的例子中，
class Store {
public:
Store(string storeName, string storeType);
int getId();
static int nex
浏览 6提问于2022-02-23得票数 -1
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
回答已采纳
2回答
我想知道C++中的所有常量是否都具有静态持续时间，即使它们是在main()以外的函数中创建的？
例如
const int a = 3;
int main()
{
const int b = 4;
}
A和b之间有什么区别？
浏览 0提问于2018-04-15得票数 2
回答已采纳
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回答
静态初始化是很好的描述主题，，甚至在这个站点。
在任何地方，如果存在不同的编译单元和相关的静态变量，就会出现这样的问题。如果静态变量存在于一个编译单元中，就不会出现问题:它们将按照它们在文件中的位置进行初始化。
但我有个密码：
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
回答已采纳
另一个问题是“谁在g++和clang++之间？”C++标准大师。
以下代码
template <int>
struct foo
{
template <typename>
friend void bar ()
{ }
};
int main ()
{
foo<0> f0;
foo<1> f1;
}
使用clang++编译时没有问题(只有两个“未使用的变量”警告)，但是给出了以下错误
tmp_002-11,14,gcc,clang.cpp: In instantiation of ‘struct
浏览 1提问于2018-05-05得票数 9
回答已采纳
在下面的库代码中：
#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
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
回答已采纳
#include <iostream>
using namespace std;
template<const int arr[]>
struct S {
static constexpr int value = arr[0];
};
constexpr int arr[] = { 5 };
int main() {
cout << S<arr>::value << endl;
}
该程序使用gcc 5.1及更高版本编译并打印5，但MSVC 19.10.25019出现以下错误：
错误C2975：'S&
浏览 7提问于2017-04-20得票数 4
回答已采纳
2回答
我最终成功地将我的单块模板库编译失败归结为一个简单的测试用例。MSVC不同意Clang和GCC关于代码格式错误的意见，主要是因为查找名称。不幸的是，我不擅长阅读C++规范，我倾向于相信Clang和GCC的一致性，但是你能帮我找到规范的相关部分吗？
namespace A
{
template <int _I, int _II>
struct X {};
}
namespace B
{
template <int _J>
struct X {};
// Clang: OK
// GCC: OK
// MSVC:
浏览 2提问于2016-04-11得票数 3
回答已采纳
我在文件tracker.hpp中有一个变量：
namespace TRIALS
{
static thread_local int a = -1;
}
文件中还有一个名为ema.hpp/ema.cpp的EMP类。
namespace Algo
{
class EMP
{
public:
void Sample();
};
}
namespace Algo
{
void EMP::Sample()
{
std::cout << "model " << s
浏览 1提问于2019-10-07得票数 3
回答已采纳
1回答
以下代码片段在g++和clang++下运行良好：
// bsp1.cc
class A {
public:
A(int, char const *);
int value;
const char * name;
};
class B {
public:
static const A many_as[];
};
A const B::many_as[]
{ { 0, "zero" },
{ 1, "one" },
{ 2, "two" },
{ 3, "three" },
浏览 5提问于2013-01-14得票数 6
回答已采纳
3回答
GCC并没有对我所做的一个我希望它会出错的例子说错：
class CannotBeCopied {
public:
CannotBeCopied(const CannotBeCopied&) = delete;
CannotBeCopied& operator=(const CannotBeCopied&) =delete;
CannotBeCopied() { }
~CannotBeCopied() { }
};
template<class T>
class FirstVector {
public:
First
浏览 2提问于2015-02-18得票数 0
回答已采纳
2回答
我有一些遗留代码，我需要为消息添加一个新的类(这与我的问题无关)。但事实证明，我需要声明一个空的构造函数，以便初始化一些静态构造函数。不是默认的构造函数或编译器提供的，而是空的用户定义的。我试图将代码简化为MWE，这里我得到的是：
#include <iostream>
using namespace std;
struct Test
{
Test() {cout << "Test::Test()" << "\n";}
void dummy(){}
};
template<typename T>
浏览 5提问于2017-05-04得票数 3
回答已采纳
我很难决定这段代码是否应该编译，或者如果我尝试过的这两个编译器都有错误(GCC 4.2和Studio 12)。通常，如果您在头文件中声明了一个静态类成员，则需要在某个源文件中定义它。然而，静态const积分标准中有一个例外。例如，允许这样做：
#include <iostream>
struct A {
static const int x = 42;
};
不需要在类体之外添加x的定义。我试图做同样的事情，但我也把x的地址传递给一个模板。这会导致链接器错误，抱怨缺乏定义。下面的示例没有链接(缺少A：：X的定义)，即使它们都位于同一个源文件中：
#include <
浏览 3提问于2009-08-10得票数 2
回答已采纳
请考虑下面的小例子
// CFoo.hpp
class CFoo{
private:
static const double VPI = 0.5;
public:
double getVpi();
};
// CFoo.cpp
#include "CFoo.hpp"
double CFoo::getVpi(){
double x = -VPI;
return x;
}
// main.cpp
#include "CFoo.hpp"
int main(){
CFoo aFoo();
ret
浏览 0提问于2012-11-12得票数 2
回答已采纳
代码：
#include <memory>
struct Data;
std::unique_ptr<Data> make_me();
int main()
{
std::unique_ptr<Data> m = make_me();
return 0;
}
当然哪一个失败了：
In file included from <source>:1:
In file included from /opt/compiler-explorer/gcc-7.1.0/lib/gcc/x86_64-linux-gnu/7.1.0/../../
浏览 2提问于2017-12-21得票数 15
回答已采纳
1回答
外型模板对gcc不管用吗？
、、、、
C++11引入了一个名为“extern”的特性，它表明模板实例存在于其他翻译单元中。(我说得对吗？)
这个()讲座还告诉我们，如果您指定外部模板而不包括实例化，链接器将产生错误。(视频中大约2:25 )
因此，我尝试构建下一个代码：
#include <iostream>
template<class T>
struct Foo
{
static constexpr int type_size = sizeof(T);
};
extern template struct Foo<int>;
int main()
{
std::cout&l
浏览 2提问于2014-05-13得票数 2
回答已采纳
1回答
我试图理解下面的代码片段
片段#1
template <typename T>
struct A
{
static constexpr int VB = T::VD;
};
struct B : A<B>
{
};
gcc9和clang9都不会在这里抛出错误。
问:为什么这段代码要编译？我们不是在从B继承时实例化A<B>吗？B中没有VD，所以编译器不应该在这里抛出一个错误吗？
片段#2
template <typename T>
struct A
{
static constexpr auto AB = T::AD; // &l
浏览 5提问于2019-12-16得票数 8
回答已采纳
我用的是GCC 4.8.2：
$ g++ --version
g++ (GCC) 4.8.2
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
我有这样的定义：
#pragma once
#in
浏览 2提问于2013-11-02得票数 0
回答已采纳
3回答
在C++ Primer 4 12.6.2中，建议在类之外重新声明const静态变量。
然而，下面的代码在gcc 4.6.3中通过。
#include <iostream>
using namespace std;
class X {
public:
const static int a = 1;
};
// const int X::a;
int main() {
X x;
cout << x.a << endl;
return 0;
}
我们应该重新申报吗？
PS:
按照Potatoswatter的建议，我添加
浏览 2提问于2014-05-03得票数 4
回答已采纳
2回答
以下代码编译得很好：
#include <type_traits>
template <typename T> struct dependent_true : std::true_type { };
template <typename T> struct dependent_false : std::false_type { };
template <bool B = false>
class X { static_assert(dependent_false<X>::value); };
template <>
浏览 0提问于2018-09-02得票数 3
回答已采纳
1回答
我遇到了以下代码，其行为被GCC、Clang和MSVC所有人都不同意：
#include <concepts>
template<typename T>
auto foo(T);
template<typename U>
struct S {
template<typename T>
friend auto foo(T) {
return U{};
}
};
S<double> s;
static_assert(std::same_as<decltype(foo(42)), doub
浏览 9提问于2022-06-13得票数 6
回答已采纳
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
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
