除非被引用，否则不会创建模板类的静态成员
被引用的情况下，创建模板类的静态成员是指在模板类中定义一个静态成员，该成员在每个实例化的模板类中共享相同的值或状态。静态成员是属于类本身而不是类的实例的，因此它们在所有实例之间共享。
创建模板类的静态成员可以通过在模板类中使用静态关键字来实现。静态成员可以是静态变量、静态函数或静态常量。
静态成员的优势在于：
- 共享数据：静态成员在所有实例之间共享，可以用于存储需要在所有实例中共享的数据。
- 节省内存：静态成员只有一个副本，不会为每个实例分配内存，因此可以节省内存空间。
- 方便访问：静态成员可以通过类名直接访问，不需要创建类的实例。
静态成员的应用场景包括但不限于：
- 计数器：可以使用静态成员来实现一个全局计数器，用于统计类的实例化次数。
- 共享资源：可以使用静态成员来共享某个资源，例如数据库连接池。
- 工具类：可以使用静态成员来实现一些通用的工具函数，例如数学计算、字符串处理等。
腾讯云相关产品中，与静态成员相关的产品和服务可能包括：
- 云函数（Serverless Cloud Function）：腾讯云云函数是一种事件驱动的无服务器计算服务，可以用于编写和运行无需管理服务器的代码。可以通过云函数来实现静态成员的功能。 产品介绍链接：https://cloud.tencent.com/product/scf
请注意，以上仅为示例，实际上腾讯云可能没有专门针对静态成员的产品或服务。
相关·内容
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
回答已采纳
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
回答已采纳
当我用g++ --std=c++98 -Wall -Werror -Wpedantic Test.cc编译下面的内容时，没有错误。
template <class T>
struct TemplateClass {
T *ptr;
TemplateClass(T *p): ptr(p) {}
int foo() {
return ptr->bar();
}
};
struct ExampleClass {
};
int main() {
TemplateClass<ExampleClass> x(new ExampleClass
浏览 1提问于2016-04-13得票数 6
回答已采纳
让我们举个例子：
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
回答已采纳
可能重复：
编辑:有一个副本，但我会放弃这个，因为我个人有困难找到它。此外，以下是帮助我的答案：
假设有以下类：
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
回答已采纳
说：
实例化类模板不会导致其成员定义被实例化。
我无法想象C++中的任何类都会被实例化，不管是从模板还是非模板，在那里类成员也没有被实例化？
浏览 0提问于2013-05-22得票数 6
回答已采纳
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
回答已采纳
为什么使用std::queue容器创建std::vector不会引发编译器错误？
只有当pop被调用时才会发生编译器错误(这很明显，因为向量不提供pop_front())。
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main()
{
queue<int, vector<int>> s;
s.push(10);
cout << s.front() << endl;
浏览 4提问于2015-08-15得票数 4
回答已采纳
1回答
我有两个具有静态成员实例的类的测试用例。前者使用非模板化的示例，而第二个则依赖于一般对象类型。
这个困境很简单:静态成员的构造函数在主函数之前被调用(正如它应该的那样)，但只对特定的对象类型调用。泛型类型不具有相同的行为。事实上，构造函数根本没有编译。看来编译器决定完全忽略它作为优化的一种手段(不是完全正确的)。
我想知道发生了什么事，以及如何才能使它以最优雅的方式运作。我想最明显的答案是:在代码中的某个地方使用静态成员。我不想这样做，因为除了在构造函数中执行一些“工作”之外，特定类型的情况不需要使用静态成员。
代码示例：
///////////////////////////////////
浏览 2提问于2014-02-20得票数 2
回答已采纳
如果没有使用静态成员，则是否在模板类中初始化静态成员变量？我用它来注册类型。
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
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
回答已采纳
这些表达式都是普通类型的定义：
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
回答已采纳
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
回答已采纳
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
回答已采纳
下面是我要创建的池对象的一个最小工作示例(显然不是功能完成--我只是想说明我遇到的问题)
我有一个类模板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
回答已采纳
2回答
我希望允许一个类从一个基类CRTP继承，这个基类导致在main()开始之前创建并运行一个全局构造函数。我们的想法是使用它在一些映射中注册一个类型，以便稍后查找。似乎只有当我实例化了派生类的成员并使用了基类时，这才能起作用。
#include <iostream>
class Foo {
public:
Foo() { std::cout << "Foo" << std::endl; }
};
template <typename T>
class Bar {
private:
static Foo foo_;
};
浏览 0提问于2014-02-22得票数 0
C++语言标准规定了关于标准库中的模板组件的以下内容：
在实例化模板组件时，除非特别允许该组件使用不完整的类型作为模板参数，否则效果是undefined...if (C++11§17.6.4.8/2)。
以下操作是否会导致std::vector类模板的实例化？
class X;
std::vector<X> f(); // Declaration only; we will define it when X is complete
换一种方式，在函数声明std::vector<X> f();中，std::vector是用参数X实例化的吗？或者，在使用或定义std::v
浏览 40提问于2011-10-12得票数 19
回答已采纳
1回答
我有一个函数void f<int N>()。只使用模板参数1和2调用f，例如f<1>()和f<2>()，而我为这两个参数高效地专门化了f。f将永远不会被任何其他参数调用，但是我还是用通用N定义了f，只是为了“清晰”。问题:如果是这样的话，编译器还会实例化这个未使用的f<N>()**?**定义吗?我觉得这会造成代码膨胀，因为我有几十个这样的函数，它们位于程序的性能非常关键的领域。
(相反，我正在考虑注释f<N>()定义，并将其替换为一个空定义，即void f<N>(){})。
浏览 3提问于2015-01-05得票数 1
回答已采纳
考虑以下代码：
#include <iostream>
struct M {
M() { std::cout << "M\n"; }
};
template <class T>
struct Test {
Test() { std::cout << "Test\n"; }
inline static auto m = M{};
};
int main() {
Test<int> t1;
//Test t;
//(void)&t1.m;
}
使用
浏览 4提问于2020-10-06得票数 4
回答已采纳
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
回答已采纳
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
1回答
(对不起，标题太乱了。我很乐意接受改进的建议。
我会尽量直截了当。我有民俗密码：
file1.hpp
template <class val_t>
struct MatOps;
文件2.：
#include "file1.hpp"
template <> struct MatOps<float>{
static void method1(){
// Do something
}
static void method2(){
// Do something
}
static void method3(){
浏览 4提问于2018-05-14得票数 1
回答已采纳
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
class Cell
{
private:
POINT mCellStartingPoint;
int mXoffset;
int mYoffset;
public:
static void DrawRowOfPixels(int yoff);
Cell();
~Cell();
};
//.cpp
void Cell::DrawRowOfPixels(int yoff)
{
HDC dc = GetDC(NULL);
COLORREF red = 0xFF0000;
for(
浏览 1提问于2013-04-06得票数 2
回答已采纳
我刚开始了解一些模板基础。事实上，直到现在我才接受这是一个事实，但我不太明白为什么这是坏的原因：
template <typename T,bool hasFoo>
struct Broken {
void foobar(){
if (hasFoo){T::foo();}
else { std::cout << "BROKEN" << std::endl;}
}
};
int main(){
Broken<int,false> t;
t.foobar();
}
虽然
浏览 8提问于2015-11-11得票数 3
回答已采纳
我正试图找到一种简单的方法(使用预C++11，即不使用decltype)来记录模板对类型的哪些要求才能正常工作。也许有更好的方法来做这件事。不过，我的问题是：
#include <iostream>
template <typename T> struct Foo {
static const int test = sizeof(T::size);
};
template <typename T> struct DetectAndError {
DetectAndError() { int test = sizeof(T::size);
浏览 2提问于2016-11-02得票数 3
回答已采纳
工作草案N4527 3.8basic.lifep7说：
如果在对象的生存期结束后，在对象占用的存储被重用或释放之前，在原始对象占用的存储位置创建一个新对象，指向原始对象的指针，引用原始对象的引用，或原始对象的名称，则可以自动引用新对象，并且一旦新对象的生存期启动，就可以使用它来操作新对象，如果：
(7.1) -新物体的储存正好覆盖原来物体所占的储存位置，及
(7.2) -新对象与原始对象的类型相同(忽略顶级cv-限定符)，以及
(7.3) -原始对象的类型不是const限定的，并且，如果是类类型，则不包含任何类型为const限定或引用类型的非静态数据成员，以及。
(7.4) -原始对象是T型
浏览 1提问于2015-07-11得票数 2
回答已采纳
2回答
何时实例化模板类的特殊成员函数？
、、、、
何时实例化模板类的特殊成员函数(特别是复制/移动构造函数和复制/移动赋值操作符)？当类本身被实例化时，还是只在需要它们的时候？
这种情况出现在以下情况：
template <class T, class U>
struct pair
{
T first;
U second;
pair() : first(), second() {}
pair(const pair&) = default;
};
struct S
{
S() {}
S(const S&am
浏览 5提问于2012-04-29得票数 9
回答已采纳
1回答
我认为下面的代码应该输出sum sizeof(int) + sizeof(float) + sizeof(std::string)，但存储值始终为零。为什么？
struct Base {
static int IncrementID(int x) {
static int id = 0;
storage += x;
return id++;
}
static int storage;
};
int Base::storage = 0;
template<typename T>
struct Object :
浏览 0提问于2019-07-06得票数 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
回答已采纳
1回答
我有一个'ModelManager‘类，它是从一个模板类'TModelManager’派生的。他们的声明如下：
template<class TModel,class TModelMesh,class TModelSubMesh>
class TModelManager
{
protected:
static std::map<std::string,ModelHandle> m_models;
static std::vector<std::map<std::string,ModelHandle>::itera
浏览 4提问于2015-03-07得票数 0
回答已采纳
2回答
我有一个基本的抽象日志记录器类，它有一个实例变量，我希望在创建代码时由派生类自动设置该变量。下面是基类：
abstract public class CLog
{
/** Maintains the call stack level for each thread */
private static HashMap<Integer, Integer> callStackLevel = new HashMap<Integer, Integer>();
/** Static instance to be set by the derived cl
浏览 1提问于2011-04-20得票数 0
回答已采纳
1回答
考虑下面的模板类
template<typename T>
struct Caller {
void func(const T &t) { t.func(); }
void gunc(const T &t) { t.gunc(); }
};
现在，让某些类Target只提供成员函数func()，而不提供gunc()，即
struct Target {
void func() const { /* ... /* }
};
模板实例化Caller<Target>有效吗？
GCC、clang以及VC++都接受这样的模板实例化。当然，调用
浏览 3提问于2016-07-22得票数 2
如果我不在未使用的模板类中初始化const变量，编译器为什么不抛出一个错误？如果我删除了template关键字，编译器就会如愿地抱怨。
此代码工作(意外)：
#include <iostream>
template<class T>
class Matrix {
private:
const uint8_t numRows, numColumns;
T content[];
public:
Matrix(uint8_t numRows, uint8_t numColumns)
// : numRows(numRows), numCo
浏览 5提问于2021-05-07得票数 2
回答已采纳
2回答
template <typename T>
class A
{
public:
A() {p = this;}
static A *GetP() {return p;}
private:
static A *p;
static A instance;
}
template <typename T>
A<T> *A<T>::p = (A<T> *)4534; //just test value to check whether p is initiallized or not.
浏览 0提问于2014-07-26得票数 1
5回答
考虑这样一个类：
template < class T >
class MyClass
{
private:
static T staticObject;
static T * staticPointerObject;
};
...
template < class T >
T MyClass<T>::staticObject; // <-- works
...
template < class T >
T * MyClass<T>::staticPointerObject = NULL; // <--
浏览 0提问于2010-08-05得票数 2
回答已采纳
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回答
静态初始化是很好的描述主题，，甚至在这个站点。
在任何地方，如果存在不同的编译单元和相关的静态变量，就会出现这样的问题。如果静态变量存在于一个编译单元中，就不会出现问题:它们将按照它们在文件中的位置进行初始化。
但我有个密码：
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
回答已采纳
我发现了一个代码片段，它在clang++ 4(和主干)中编译和工作正常，但在g++ 7(和主干)中无法编译。让我们假设我有以下struct类型：
struct a { void foo() { } };
struct b { void bar() { } };
struct c { void bar() { } };
我想要创建一个由lambda设置的重载，它显式地处理a，而b和c则使用使用auto参数的通用lambda“捕获”：
auto ol = overload([](a x) { x.foo(); },
[](auto x){ x.bar();
浏览 1提问于2017-05-15得票数 11
回答已采纳
2回答
我在C++中看到了下面的程序
template <class T>
class Val {
protected:
T x0, x;
public:
Val(T t = 1) : x0(t), x(1) {}
T val() { return x; }
void promote() { this->promote_value(); }
};
由于某种原因，即使没有方法Val<int>(4).val();，promote_value()也可以正常工作。我试图删除模板：
class OtherVal {
protected:
in
浏览 1提问于2019-07-04得票数 11
回答已采纳
2回答
以下代码无法按预期编译：
#include<iostream>
class Enclosing {
int x;
class Nested { int y; };
void EnclosingFun(Nested *n) {
std::cout << n->y; // Compiler Error: y is private in Nested
}
};
但是，如果我将EnclosingFun转换为模板成员函数，编译器(gcc-7)不会抱怨访问y：
#include<iostream>
class E
浏览 0提问于2018-03-11得票数 3
回答已采纳
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
回答已采纳
1回答
我有一个带有静态实例的模板单例类和一个静态getInstance()方法。但是，我从g++ (MinGW)中得到了一个未定义的引用错误；起初，我认为这是链接器顺序错误，但是不管我把它们放在哪一个顺序上，我都得到了相同的结果。
但是，我发现如果我显式地专门化了实例，它就会编译(这不是一个可接受的解决方案)。下面是代码：
Singleton.hpp：
#ifndef SINGLETON_HPP
#define SINGLETON_HPP
#include <iostream>
template<int X=100>
class Singleton {
protected
浏览 4提问于2013-10-13得票数 2
1回答
在c#中，静态成员对于每个泛型类都是唯一的，如下例所示
using System;
//A generic class
public class GenTest<T>
{
//A static variable - will be created for each type on refraction
static CountedInstances OnePerType = new CountedInstances();
//a data member
private T mT;
//simple constructor
public GenTest(
浏览 1提问于2013-06-16得票数 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回答
以下是GCC 4.8.1 (与--std=c++11一起)的编译：
struct non_default_constructible { non_default_constructible() = delete; };
template<class T>
struct dummy {
T new_t() { return T(); }
};
int main(int argc, char** argv) {
dummy<non_default_constructible> d;
return 0;
}
棘手的部分是dummy<non_d
浏览 3提问于2014-09-30得票数 12
回答已采纳
4回答
派生类中的显式模板静态成员实例化
、、、、
我试图用一个静态成员来实现一个模板类。从模板类派生的类应该实例化，而不需要编写额外的代码。
以下是我天真(但不成功)的方法：
辛尼顿
template <class T> class Singleton {
protected:
Singleton();
static T instance_;
}
// explicit instantiation of 'instance_' ???,
// where 'instance_' is an instance of the derived class
template <class
浏览 0提问于2015-01-15得票数 6
回答已采纳
2回答
模板的静态成员
、、
还有一个类似的问题，但它与带有typename关键字的模板相关。
给定一个模板：
template < int X, char Y >
struct foo
{
char myArray[ X <= 0 ? 1 : X ];
static const char Z = Y;
}
这个静态成员是否会在foo的所有实例之间共享，或者编译器是否会看到模板已被不同的参数调用并创建一个新类型？
浏览 2提问于2013-07-17得票数 0
回答已采纳
2回答
我正在编写一个类IteratorIterable，它封装了一个容器类(一个带有返回一些迭代器的begin()和end()方法的类)，以便能够在包装类的迭代器上进行迭代。这个想法是基于的。我的代码如下所示(为了简洁起见，有些方法漏掉了)：
template <class T>
class IteratorIterable
{
private:
T& container;
public:
typedef decltype(container.begin()) BackendIterator;
public:
class IteratorIterato
浏览 0提问于2014-08-20得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
