根据模板参数添加成员函数和成员变量
是一种编程技术，用于根据模板参数在编译时生成不同的代码，以实现代码的复用和灵活性。下面是对该问答内容的详细解释：
- 模板参数：模板参数是指在定义模板时，可以根据具体需求指定的类型、值或其他参数。模板参数可以是基本类型（如整数、浮点数、布尔值等），也可以是类、结构体、枚举等自定义类型。在根据模板参数添加成员函数和成员变量时，可以根据参数的类型或值来选择性地生成不同的代码。
- 添加成员函数：通过模板参数，可以在类或结构体中添加不同的成员函数。这样可以根据模板参数的具体类型来定制类的行为。例如，可以根据模板参数的类型来选择是否添加某个特定的功能，或者根据参数值来决定函数的实现细节。通过这种方式，可以实现更加灵活和高效的代码复用。
- 添加成员变量：同样地，通过模板参数，可以在类或结构体中添加不同的成员变量。这样可以根据模板参数的具体类型或值来定制类的数据结构。通过模板参数添加成员变量可以提高代码的可扩展性和适应性，使得类能够更好地满足不同场景下的需求。
- 优势：使用模板参数来添加成员函数和成员变量有以下优势：
- 代码复用：可以根据不同的模板参数生成不同的代码，避免重复编写相似的代码，提高代码的复用性。
- 灵活性：可以根据模板参数的不同来定制代码的行为和数据结构，使得代码能够适应不同的场景和需求。
- 高效性：由于模板参数是在编译时确定的，可以在编译阶段进行优化，提高程序的执行效率。
- 应用场景：根据模板参数添加成员函数和成员变量适用于各种需要根据不同情况进行定制化的场景，包括但不限于：
- 数据结构：根据不同的模板参数类型来定制化数据结构，例如树、链表、队列等。
- 算法实现：根据不同的模板参数值来选择不同的算法实现方式，例如排序算法、搜索算法等。
- 接口设计：根据不同的模板参数类型来定义不同的接口，并提供相应的实现。
- 腾讯云相关产品：腾讯云提供了丰富的云计算产品和解决方案，可以满足各种云计算需求。在使用根据模板参数添加成员函数和成员变量时，可以考虑以下腾讯云产品：
- 云服务器（Elastic Compute Cloud，EC2）：提供可定制的虚拟机实例，可满足不同规模和性能要求的应用场景。链接地址：https://cloud.tencent.com/product/cvm
- 云数据库（TencentDB）：提供全球分布式的数据库服务，支持多种数据库引擎和存储类型，满足不同的数据管理需求。链接地址：https://cloud.tencent.com/product/cdb
- 云原生应用平台（Cloud Native Application Platform，TKE）：提供容器化的应用部署和管理平台，支持灵活的弹性伸缩和自动化运维。链接地址：https://cloud.tencent.com/product/tke
通过使用这些腾讯云产品，可以快速部署和管理云计算环境，提高开发效率和系统可靠性。
总结：根据模板参数添加成员函数和成员变量是一种通过在编译时生成不同代码以实现代码复用和灵活性的技术。它可以根据模板参数的类型或值来定制类的行为和数据结构，并可以应用于各种场景。在使用该技术时，可以考虑使用腾讯云提供的产品和服务来支持云计算需求。
相关·内容
我正在使用CUDA 11编译一个具有扩展lambda表达式特性的项目，我发现以下代码无法通过使用NVCC (CUDA 11.8)的编译
// test.cu
#include <iostream>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <type_traits>
template<typename Lam>
__global__ void map(int n, Lam func) {
int tid = blo
浏览 6提问于2022-11-07得票数 1
下面的代码是我试图为客户需求实现的一个功能的简化的最小版本。
它无法在IBM编译器(version 9和version 11 )上编译，并出现错误A non-type template parameter cannot have type "int X::*".。然而，我已经在g++ 4.7.2，clang++ 3.2和Intel13.0上尝试了相同的代码，他们成功地编译了它。
我很想知道XLC是这里唯一明智的声音，还是其他编译器是正确的？
struct X {
X() : y(123) {}
int y;
};
struct XFoo {
typede
浏览 1提问于2013-02-05得票数 0
回答已采纳
我发现了一个代码片段，它在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
回答已采纳
我有一个iOS应用程序，它使用来自MPL的一个C++类，名为‘square.h.h’，每当我构建这个应用程序时，Xcode就会抛出这个错误-
无法将默认参数添加到类模板成员的行外定义中。
现在，我对C++语法的理解很少，那么这个错误意味着什么呢？
问题线在以下-
template <class T>
TSquare<T>::TSquare (T size_, T x_, T y_, T scale_=0)
{
size = size_;
x = x_;
y = y_;
scale = scale_;
}
浏览 11提问于2014-09-03得票数 9
回答已采纳
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
回答已采纳
我看过建议成员函数使用this->显式引用成员变量，以避免忘记声明成员变量和意外引用全局变量。如果有人认为这是一种合理的预防措施或不必要的冗长，会不必要地使代码阅读复杂化，那么任何人都可以发表评论吗？有没有人在日常生活编程中做到这一点？
浏览 0提问于2012-12-03得票数 2
回答已采纳
的后续行动。假设占位符可用于推断函数指针的结果类型，构成非类型模板参数。c++17是否允许在传递给模板函数名时执行重载解析--而不知道结果类型，这是执行隐式转换所需的吗？
template <auto(*)(int)>
struct Foo { };
int bar(int);
float bar(float);
int main() {
static_cast<void>(Foo<bar>{});
}
和似乎都接受这个代码。
浏览 1提问于2018-01-28得票数 5
回答已采纳
以下是有效的C++11吗？构造函数NoWay::NoWay的两个参数都有默认值，但一个在声明中指定，另一个在定义中指定。
#include <iostream>
class NoWay {
private:
int foo;
bool bar;
public:
explicit NoWay(int foo, bool bar = true);
bool isGood();
};
NoWay::NoWay(int foo = 4, bool bar) {
this->foo = foo;
this->bar = bar;
}
bool No
浏览 0提问于2017-08-25得票数 3
回答已采纳
1回答
我在使用Apple编译器时遇到了一个问题(随XCode 4.5.2一起提供的)，同时与GCC一起正确运行。更重要的是，比起对编译器问题的辩论(我认为GCC是对的)，这就提出了当重载操作符涉及到1时模板专业化的解决顺序的问题。
考虑一个简单的矩阵类template <class T> class matrix_t，它的特征定义了乘法的结果类型(包括标量、矩阵或向量)。下面的代码如下所示：
template <class T, class U, class Enable = void>
struct matrix_multiplication_traits {
//ty
浏览 2提问于2013-02-22得票数 4
回答已采纳
3回答
在C++11中本地类的用法有什么变化吗？
在C++03中，本地类似乎不能用作模板参数(我记得)。
考虑这段代码，
template<typename T> void f(const T&) {}
//Note : S is a local class defined inside main()
int main() { struct S{}; f(S()); } //I want template argument to be deduced.
但是它给出了编译错误(C++03模式)，即()：
prog.cpp:4: error:调用‘f(main()：：s)’没有匹
浏览 7提问于2011-11-20得票数 21
回答已采纳
显示，std::shared_ptr有一个模板化和非模板化的复制/移动构造函数版本(页面上有(9)和(10) )。类似地，它还有两个版本的复制/移动赋值操作符(参见)。
为什么我们需要非模板版本？单凭模板版还不够吗？
浏览 2提问于2016-07-23得票数 2
回答已采纳
3回答
我有以下代码：
template<int k>
void foo()
{
}
int main(int argc, char* argv[])
{
int k = 1000;
foo<k>();
return 0;
}
它不会编译，但如果我将k声明为const，它就会编译：
template<int k>
void foo()
{
}
int main(int argc, char* argv[])
{
const int k = 1000;
foo<k>();
return 0;
}
现在，我明白
浏览 2提问于2011-11-23得票数 5
回答已采纳
假设我有一个模板类声明如下：
template< int *x > struct y { int *b; y() { b = x; }}
我确实需要模板参数是一个常量内存地址-它是一个嵌入式代码。如果我试图像这样实例化它：(编译器是gcc 4.8.1和-std=gnu++11)
y< 1 > c;
我将得到一个错误“无法转换模板参数'1‘到'int*'”，这是很好的，按照标准。我能理解。
我的问题是，对指针的转换也不起作用：
y< (int *)1 > d;
y< reinterpret_cast<int *>
浏览 3提问于2014-06-27得票数 6
1回答
我编写了以下隐藏成员函数模板的代码。
#include <iostream>
struct A
{
template<int> void func()
{
std::cout<<"Function tamplate of A"<<std::endl;
}
};
struct B : A
{
template<char> void func()
{
std::cout<<"Function tamplate of B
浏览 1提问于2017-10-16得票数 23
回答已采纳
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回答
下面的代码可以使用gcc和clang (以及许多其他C++11编译器)进行编译。 #include <stdint.h>
typedef int datatype;
template <typename T>
struct to_datatype {};
template <>
struct to_datatype<int16_t> {
static constexpr datatype value = 1;
};
template <typename T>
class data {
public:
data(da
浏览 18提问于2020-01-01得票数 13
回答已采纳
这些表达式都是普通类型的定义：
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
回答已采纳
5回答
将数组/指针作为模板参数传递
、、、、
我正在尝试创建以下类型的模板函数：
template <bool isHorizontal, float* kernel>
__global__ void smoothFilterColumns(const TwImageCUDA_Device* source, TwImageCUDA_Device*
destination)
{
// code...
}
(不要担心__global__，这是在CUDA上实现的。)
不幸的是，它不允许我像这样创建这个函数的实例：
float ptrKernel[] = {1, 2, 1};
smoothFilterColumns<true,
浏览 7提问于2011-04-08得票数 2
回答已采纳
我不明白这背后的原因:为什么使用私有类型的显式专门化允许类模板，而不允许函数模板？
假设我们有一堂课：
class pepe
{
struct lolo
{
std::string name = "lolo";
};
public:
static lolo get()
{
return {};
}
};
类模板可以显式地专门化。
函数模板在隐式实例化方面没有问题。
虽然您不能创建spec_class<pepe::lolo>{}，因为pepe::lolo是不可访问的。
浏览 3提问于2022-05-15得票数 13
回答已采纳
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
回答已采纳
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
回答已采纳
1回答
如果我创建了一个指向基成员的指针，我通常可以将它转换为指向派生成员的指针，但当在下面的Buzz这样的模板中使用时就不能了，因为第一个模板参数会影响第二个模板参数。我是在与编译器bug作斗争，还是标准真的要求这样做不起作用？
struct Foo
{
int x;
};
struct Bar : public Foo
{
};
template<class T, int T::* z>
struct Buzz
{
};
static int Bar::* const workaround = &Foo::x;
int main()
{
// This
浏览 0提问于2010-10-27得票数 5
回答已采纳
3回答
模板元编程问题
、、
template <int p>
bool FComapare (Node *lId, Node* rId)
{
if(lId->getDiff(p) < rId->getDiff(p))
return true;
else if(lId->getDiff(p) == rId->getDiff(p))
{
if(lId->getLT() < rId->getLT())
return true;
else if(lId
浏览 4提问于2010-12-19得票数 0
回答已采纳
1回答
维基百科为提供了一个有趣的模板。
这个模板提供了一些有趣的东西，因为它允许提供关于成员访问的逻辑。在此基础上，我们可以轻松地构建这样的东西：
struct Ranged {
ranged_property<float,0,1> unit_property;
};
其中unit_property的范围强制为0,1。
我们如何提供依赖于宿主类成员的类似功能？例如：
struct AdjustableRanged {
float max;
ranged_property<float,0,max> influenceable_property;
};
其
浏览 4提问于2014-10-22得票数 0
回答已采纳
1回答
在函数模板的定义中使用的模板参数包，在定义中只给出该参数所需的默认值，而不是声明的情况下，是否可以后面跟着另一个模板参数？请考虑以下示例：
template <typename ...Ts, typename T>
auto sz(Ts...);
template <typename ...Ts, typename T = int>
auto sz(Ts...) { return sizeof...(Ts); }
我发现GCC和Clang在这个问题上意见不一致(GCC给出了一个编译错误)。
浏览 0提问于2019-06-29得票数 4
回答已采纳
2回答
我有两个模板类，第一个是：
template <typename T>
class LL_iterator
{...};
以及：
template <class T>
class LL
{...}
现在，问题是我试图在具有'LL_iterator‘返回类型的'LL’类中编写一个函数声明。'LL‘类中的函数如下所示：
LL_iterator<T> begin();
我所收到的错误如下：
Error 1 error C2143: syntax error : missing ';' before '<
浏览 2提问于2015-03-29得票数 1
回答已采纳
1回答
理解函数指针和引用
、、、、
考虑以下类型：
template <class R, class... Args> using type0 = R(Args...);
template <class R, class... Args> using type1 = R(*)(Args...);
template <class R, class... Args> using type2 = R(&)(Args...);
template <class R, class C, class... Args> using type3 = R(C::*)(Args...);
tem
浏览 0提问于2015-12-01得票数 2
回答已采纳
1回答
推导成员变量类型
、、、
编辑:我忘了回调“捕获”了outer的outer指针。
我正在尝试初始化某个类及其成员。
类是，而不是模板。
它的成员是模板。它以“函数类型”为模板，用于封装类的回调。(我不能使用std::function，因为这是时间关键代码。)
此外，我希望编译器将推导出回调对象的模板类型(提供给成员)。
代码应该是这样的(假设所有的锅炉板都存在)：
template<typename func_t>
class inner : public inner_abstract_base
{
public:
func_t m_cb;
inner(func_t cb):m_cb(cb)
浏览 3提问于2020-11-09得票数 0
我尝试实现一个模板类，它需要一个依赖于模板参数的信号成员。我的第一个想法是实现以下目标：
template<class T>
class SignalClass
{
typedef boost::signals2::signal<void (T &)> OnReceive;
public:
SignalClass(const OnReceive::slot_type &_slot)
{
m_onReceive.cnnect(_slot);
}
virtual SignalClass(){};
浏览 2提问于2010-09-06得票数 3
回答已采纳
3回答
这段代码有问题，在我从main.cpp文件中获取这个类并将其拆分到.h和.cpp之后，编译器就开始抱怨我在空中使用的默认参数。
/* PBASE.H */
class pBase : public sf::Thread {
private:
bool Running;
public:
sf::Mutex Mutex;
WORD OriginalColor;
pBase(){
Launch();
Running = true;
OriginalColor = 0x7;
}
void prog
浏览 4提问于2011-06-02得票数 73
请考虑以下几点：
#include <iostream>
template <typename T>
struct Foo
{
Foo (T v = {}) : var (v) {}
T var;
};
int main()
{
// Foo<int&> f; // cannot compile
int x = 42;
Foo<int&> f(x);
std::cout << f.var;
}
它在GCC 4.8中成功地建立和运行，但它是否严格合法？
T v =
浏览 2提问于2014-10-17得票数 7
回答已采纳
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
回答已采纳
1回答
当尝试clang-3.4 (从git编译)时，它未能编译我的一个项目，在解决重载操作符时抱怨模糊性。我发现有两个模板操作符，其中一个被声明为成员函数，另一个被声明为非会员函数，两者似乎都很匹配。
下面的SSCCE演示了这种情况：
#include <iostream>
struct ostr {
std::ostream& s;
template<class T>
ostr& operator<<(const T& x) { s << x; return *this; }
浏览 2提问于2013-11-13得票数 8
回答已采纳
2回答
我希望能够将从DBMetaData继承的对象的引用作为另一个类DBVar的非类型模板参数传递。
#include <iostream>
class DBMetaData
{
public:
virtual const char *description( ) const = 0;
};
class DBMetaData_NT
: public DBMetaData
{
public:
const char *description( ) const
{ return "Useless description.&#
浏览 0提问于2012-11-28得票数 5
回答已采纳
1回答
我对以下形式的代码有问题：
template<class Type>
class Class1 {
public:
template<class TypeName1> TypeName1* method1() const {return 0;}
};
struct Type1{};
struct Type2{};
class Class2 {
public:
template<typename TypeName1, typename TypeName2>
int method2() {
Class1<TypeNam
浏览 5提问于2013-02-11得票数 5
回答已采纳
我试图了解std::thread是如何使用的。
标题如下：
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
如何识别f是通用引用还是rvalue？从我在网上发现的：
“如果T被推导，并且变量/参数类型是不合格的T&&，那么只有它是一个通用的引用。
unqualified T&&指什么？auto还是template？
，如果我有一个函数foo，我可以调用它像std::thread(foo
浏览 1提问于2021-03-01得票数 1
1回答
gcc-4.9.2和clang-3.8在编译为C++98或C++11时都接受以下内容：
#include <cstdio>
template <typename T> void f(T) { printf("T\n"); }
template <> void f<int>(int) { printf("int\n"); } // explicit specialization
template <> void f<>(double) { printf("double\n
浏览 3提问于2015-09-25得票数 4
回答已采纳
1回答
我不明白为什么下面的代码不能工作。编译器(gcc)似乎实例化了这两个方法，显然整数要么是有符号的，要么是无符号的，所以总是失败。我以为enable_if在这里就是为了避免这种情况。
问:为什么会出现编译错误，如何避免？
using namespace boost; // or std as you want
template<typename T>
struct test {
// if signed
template< typename enable_if
< is_signed<T>
浏览 0提问于2014-12-08得票数 4
1回答
struct taskinfo{
template <class callable, class... arguments>
taskinfo(callable&& f, arguments&&... args){
std::function<typename std::result_of<callable(arguments...)>::type()> task(std::bind(std::forward<callable>(f), std::forward<argumen
浏览 0提问于2018-01-29得票数 1
回答已采纳
1回答
#include<vector>
#include<functional>
class SegmentTree final{
public:
template<typename T> using data_type=T;
public:
template<typename T=int>
explicit SegmentTree(const size_type& size);
};
我希望SegmentTree不是模板类，而是模板类型，并从构造函数中推断这种类型。我能做吗？
浏览 2提问于2021-09-12得票数 0
回答已采纳
2回答
我在用专门的破坏者做实验。这段代码是完全有效的，并且编译得很好：
#include <iostream>
using namespace std;
template <typename T>
class Cat
{
public:
~Cat();
};
template <typename T>
Cat<T>::~Cat()
{
std::cout << "T" << std::endl;
}
template <>
Cat<int>::~Cat()
{
浏览 0提问于2017-10-17得票数 1
回答已采纳
考虑以下代码片段：
#include <functional>
namespace ns {
struct Arg{};
using Func = std::function<int(Arg)>;
Func operator+(Func lhs, Func rhs) {
return [lhs, rhs](Arg arg) {
return lhs(arg) + rhs(arg);
};
}
}
int main() {
ns::Func foo = [](ns::Ar
浏览 0提问于2019-08-14得票数 6
回答已采纳
1回答
我更改了函数中的参数，以接受使用模板的任何类型的对象，但我不能将其与其他默认参数一起使用，是不是有什么我遗漏了什么？
#include <string>
#include <iostream>
class MyClass {
public:
std::wstring msg = L"hey";
MyClass(){};
};
class MyClass2{
public:
template<class T> MyClass2(T* t, int i);
};
template<class T&
浏览 1提问于2015-08-20得票数 13
回答已采纳
3回答
为什么模板专门化需要内联？
、、、、
我指的是这个答覆：
我遇到了一个与引用的问题的OP类似的问题，它有一个函数
template<typename T>
void func(T& val);
及其专业化
template<>
void func<mytype>(mytype& val);
导致重复符号链接器错误(方法在“.tpp”文件中实现，该文件包含在标题末尾)。将inline添加到专门函数中解决了这个问题。为什么？
浏览 0提问于2018-01-23得票数 14
回答已采纳
我已经开发了一个双参数二叉树，现在正在尝试应用它来创建一个字典。树中的find函数正常工作，但是，当我试图在字典类中调用它时，我会得到一个编译器错误“class‘>之前的预期主表达式”。有人能帮我弄清楚到底出了什么问题吗？我不太熟悉尝试从其他文件调用函数。
这是bst.h内部二进制搜索树中的查找函数。
V & find (K key)
{
TreeNode<K,V> *traverseFind;
traverseFind = root;
unsigned int compareT
浏览 3提问于2014-12-03得票数 0
回答已采纳
1回答
考虑到以下代码：
#include <iostream>
struct Alice
{
template <typename A>
void operator|(const A& /*a*/) const
{
std::cout << "operator| member" << std::endl;
}
};
template <typename A>
void operator|(const A& /*a*/, const Alice& /*alice*/)
{
浏览 2提问于2014-05-22得票数 34
回答已采纳
在一个Visual解决方案中，在两个项目之间链接constexpr构造函数时，我有问题。
我的Visual 2019解决方案中有两个项目：
NES_Core
NES_Core_Tests
第一个是.lib项目，另一个是基本GTest项目。两者都使用C++17。
我在NES_Core中的executor.h中声明了以下类：
namespace nes::cpu::opcodes::immediate {
class Executor
{
public:
constexpr Executor(registers::Registers&
浏览 0提问于2019-08-07得票数 0
回答已采纳
1回答
继承和成员函数模板重载
、、、
我尝试使用clang (3.0版)编译以下代码，但它给出了这个错误
error: no matching member function for call to 'a'
在调用__a.a<0>()中。然后，我尝试使用g++ (版本4.2.1)，它可以按照预期进行编译和工作(打印出1 2)。
#include <iostream>
struct A {
template <int> int a() { return 1; }
};
struct B: A {
using A::a;
template <int,int>
浏览 1提问于2011-12-18得票数 3
回答已采纳
1回答
我在linux上有一个构建在静态库中的项目，然后我想将它包含在单元测试项目和应用程序项目中。
在这个图书馆里我有这样的东西：
template<class T> class A
{
public:
virtual T doStuff() = 0;
virtual void doOther(T a) = 0;
protected:
A() { ... }
};
class B : public A<int>
{
public:
B() { ... }
virtual int doStuff() { ... }
virtu
浏览 12提问于2015-04-11得票数 0
回答已采纳
是否需要this指针？我猜如果你在函数上传递this指向的类的实例，你会需要它。但就设置/检索/调用/任何成员而言，this总是可选的吗？
我已经标记了这个C++，因为这是我特别想知道的语言，但是如果有人能确认这个结构对于Java和其他使用this指针的OO语言是相同的，我将不胜感激。
浏览 3提问于2012-03-08得票数 13
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
