枚举和指向成员的指针
好的，我已经了解了您的问题。请问您需要我为您解答什么问题呢？
相关·内容
下面的代码是我试图为客户需求实现的一个功能的简化的最小版本。
它无法在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
回答已采纳
1回答
我不明白为什么为类添加前向声明会改变其指向成员类型的指针的大小。
#include <iostream>
using namespace std;
int main()
{
//struct CL;
//cout<<sizeof(int (CL::*)())<<endl;
struct CL{};
cout<<sizeof(int (CL::*)())<<endl;
}
输出VS2013：
4.
但是，如果我取消了main()中前两行的注释，那么输出是不同的：
16
16
因此，只有简单地在stru
浏览 5提问于2015-06-18得票数 12
回答已采纳
1回答
结构定义中带有指针的枚举
、、、、
我正在使用ctype模块创建对python中动态库的访问。在复制python实现中的一些tydef结构时，我遇到了一些代码，使我对正在发生的事情感到困惑。基本上我拥有的是
enum foo {
a,
b,
c,
};
typedef struct barStruct bar;
struct barStruct{
enum foo (*lem)();
enum foo (*baz)(bar *next);
}
在头文件中。
我试图理解结构定义中的两个枚举调用。我认为第一个是创建一个名为lem的指针，它必须指向枚举中包含的值(因此实际上忽略了末尾的打开/
浏览 0提问于2016-09-15得票数 1
回答已采纳
我想要创建一个模板，在那里我可以使用不同的向量类型，和常量作为相同类型的向量。我希望能够将常量作为模板参数传递，以便让编译器对其进行优化，而不需要显式的专门化。
所以我试着重复使用类型参数，但是我得到了非法类型。
#include <vector>
using namespace std;
template<typename WEIGHT, WEIGHT multiplier>
void test_multipier(vector<WEIGHT> &v)
{
uint16_t num = 16;
/*...*/
WEIGHT
浏览 5提问于2015-10-01得票数 0
回答已采纳
1回答
在下面的代码中，我传递了类类型R和该类型的常量表达式作为模板参数。但是clang不接受这样的说法：
#include <iostream>
template<class T, T t>
void foo(){ std::cout << "foo()" << std::endl; }
class R
{
public:
int f;
constexpr R(): f(15){ }
};
constexpr R r;
int main(){ foo<R, r>(); } //note: candid
浏览 2提问于2015-02-07得票数 2
回答已采纳
1回答
如何编写此模板的定义？
fun<10>();// output is 10
fun<20>();// output is 20
浏览 0提问于2019-12-22得票数 0
1回答
这是一个常见的模板函数。
template <typename T>
void func(T param) {
// ...
}
但是，我也看到了如下模板：
template <typename T, std::size_t N> // note the extra N
void func(T param) {
// ...
}
我知道这是合法的，但显然N与参数的类型无关。在模板中添加一个额外整数的官方规则是什么？这叫什么？我是否可以将额外的模板param设置为浮点数或双倍，而不是整数？如果不是，为什么整数是特殊的？
浏览 1提问于2018-01-28得票数 1
回答已采纳
2回答
我有这个问题：
template <void (*F)(int)> struct FunctionWrapper // This compiles and works
{
static void call_it()
{
F(0);
}
};
class MyClass
{
public:
static void callMe(int k)
{
}
};
template <void (MyClass::*F)(int)> struct FunctionWrapper // Error - F in
浏览 0提问于2013-03-02得票数 2
回答已采纳
template<typename T, T Min>
class LowerBoundedType {};
template<typename T> class vectorelement {};
template<> class vectorelement<Categorical> { typedef LowerBoundedType<double, 0.0> type; };
有错误：
error: 'double' is not a valid type for a template constant par
浏览 4提问于2010-06-24得票数 11
回答已采纳
3回答
检查以下代码：
#include <iostream>
using namespace std;
int& foo() {
static int i = 0;
return i;
}
int main() {
cout << &foo() << endl;
cout << &foo << endl;
return 0;
}
正如您所看到的，第一个cout打印foo()返回值的地址，这将是foo()中的静态变量i。对于第二个cout，我期望&foo返回foo(
浏览 0提问于2018-11-03得票数 3
回答已采纳
2回答
我们知道的标量类型有：int, char, float,等，但指针也是标量类型。它是包含指向类类型的指针，还是只包含标量类型的指针？
浏览 2提问于2011-12-27得票数 1
回答已采纳
2回答
在这个27:35的中，Bryce Lelbach给出了以下示例：
template<auto... Dims>
struct dimensions {};
struct dynamic_extent {};
constexpr dynamic_extent dyn = {};
dimensions<64, dyn, 32> d;
此代码不编译。GCC抱怨说：
<source>:8:27: error: 'struct dynamic_extent' is not a valid type for a template non-type p
浏览 1提问于2018-06-21得票数 7
回答已采纳
2回答
守则：
#include <functional>
#include <type_traits>
namespace impl
{
// lame recursive implementation
template<typename Functor, Functor F, typename T, T OneValue, T SecondValue, T... Values>
struct variadic_conjunction : variadic_conjunction<Functor, F, T, F(OneValue,
浏览 0提问于2018-05-08得票数 1
回答已采纳
2回答
模板函数指针解释
、、
我对这里发生的事情感到困惑，我希望你们中的一位能帮助我理解。我把这门课提炼成了一些看似相关的方法，希望我没有遗漏任何东西。
template < int* ( foo::*member_function )( void ) >
class bar
{
public:
int myFunc( foo* myFoo )
{
int* result = ( myFoo->*member_function )();
return *result;
}
};
我不明白这怎么知道member_function是什么，没有变量，但是它
浏览 0提问于2014-02-14得票数 3
回答已采纳
应用程序可以获得内存中对象的地址表示形式。
std::cout << &obj << std::endl
我试着用指针到成员类型来做同样的事情。
#include <iostream>
using namespace std;
struct X
{
bool b;
int a;
};
int X::* a =&X::a;
bool X::* b = &X::b;
X x;
int main()
{
cout << a << endl << b; //1
浏览 0提问于2014-09-26得票数 5
回答已采纳
我定义了一个名为CallBackAtInit的类模板，它的唯一目的是在函数初始化(构造函数)时调用它。该函数在模板参数中指定。问题是模板不接受std::function作为参数；但它们接受函数指针。为什么？
下面是我的代码：
#include <iostream>
#include <functional>
/* Does not work:*/ template <typename return_type, typename arg_type, std::function<return_type(arg_type)> call_back&g
浏览 0提问于2012-12-02得票数 20
回答已采纳
所以我有一个别名模板：
template<class MemberT, class ClassT>
using make_member_ptr = MemberT ClassT::*;
我注意到make_member_ptr<int(char, long), class_type>和int(class_type::*)(char, long)是一样的。以前，我认为指向成员函数的指针与指向数据成员的指针完全不同。
指向成员函数的指针与指向数据成员的指针有何不同？
我唯一能找到的是，如果成员函数是虚拟的，通过指向基函数的指针调用将调用派生函数，这是指针非函数成员的一个非问题
浏览 0提问于2019-02-03得票数 2
回答已采纳
考虑用于C++结构type_no的以下代码
#include <iostream>
template <int i>
struct type_no {
static const int value = 0;
};
template<>
struct type_no<1> {
static const bool value = 10;
};
template<>
struct type_no<2> {
static const bool value = 20;
};
int main() {
std:
浏览 0提问于2018-02-06得票数 0
#include <iostream>
int main(){
std::cout << main << std::endl;
return 0;
}
为什么它在命令行中打印1？
浏览 1提问于2015-02-22得票数 6
在libcxx/include/type_traits中，std::is_function是以如此紧凑的方式实现的：
namespace __libcpp_is_function_imp
{
struct __dummy_type {};
template <class _Tp> char __test(_Tp*);
template <class _Tp> char __test(__dummy_type);
template <class _Tp> __two __test(...);
template <class _Tp> _Tp&am
浏览 3提问于2019-10-21得票数 4
回答已采纳
如我们所知，派生类public和protected成员的直接或间接基类在该派生类中是可用的。
所以我有个例子：
struct Foo{int x_ = 10;};
struct Bar : Foo{};
struct FooBar : Bar{
void f()const{
std::cout << &x_ << " : " << x_ << '\n';
std::cout << &Foo::x_ << " : " &l
浏览 5提问于2021-04-16得票数 6
回答已采纳
我正在使用文件boost/smart_ptr/detail/operator_bool.hpp，并遇到了以下我不理解的代码片段
typedef T * this_type::*unspecified_bool_type;
operator unspecified_bool_type() const // never throws
{
return px == 0? 0: &this_type::px;
}
我用XCode写了一些测试代码，&this_type::px总是返回1。为什么？
一些C++专家能分享你的想法吗？
浏览 2提问于2012-06-07得票数 0
2回答
我从许多其他堆栈溢出线程(如)中了解到，模板参数是在编译时计算的。此外，非类型模板参数应该是一个常量表达式、积分表达式或指向具有外部链接的对象的指针。
而且，我在Makefile中的g++命令中没有使用--std=c++0x。
那么，是否可以实例化作为参数传递为NULL的模板类？
// I have a template class like this -
template<class T, T invalidVal, int e> class A
{
static inline bool dummy(T value)
{
return 0;
浏览 4提问于2012-09-28得票数 3
回答已采纳
2回答
C++模板作为模板的参数
、、、
我遇到了以下问题。我有以下模板Number
template<int n>
struct Number
{
static const int value = n;
};
假设现在我想在编译时添加两个这样的数字。具体来说，我想让下面的片段工作起来：
//The following code should display 7:
std::cout << Number_add< Number<3>, Number<4> >::value << std::endl;
我试过这样做，但我的编译器不喜欢。
template&l
浏览 4提问于2017-03-05得票数 3
回答已采纳
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
回答已采纳
当我重载"=="和"!="操作符时，我把指针作为参数传递，并且调用重载的函数，得到了预期的结果，但在调试过程中，我发现在调用cout << (fruit1 < fruit);期间，没有调用重载的"<"方法。为什么只有"<"运算符没有被重载？我已经传递了一个引用参数来测试它，并在函数调用中测试非引用的fruit和fruit1，并且它能够工作，因此函数本身也能工作。是这些操作符的属性，还是"!="和"=="方法是内联的，允许它们工作？
CPP
#包括"Fruit.h
浏览 3提问于2013-10-08得票数 2
回答已采纳
2回答
非类型模板参数
、、
考虑到这一点：
#include <set>
template <typename T, T val>
class sample {
public:
// Return val for new elements.
T& at(unsigned i) {
auto o = _set.insert(val);
return *o.first;
}
private:
std::set<T> _set;
};
class s {
public:
constexpr s() = defa
浏览 2提问于2019-12-30得票数 2
回答已采纳
3回答
我最近发现在C++中有一个对函数的引用概念:)。因此，由于有指向函数的指针和指向成员函数的指针两种不同的类型。问题就出现了。有没有“对成员函数的引用”的概念？
我试图编译下面的代码，但GCC 3.4.6给出了一个错误。
#include <iostream>
using namespace std;
class A {
public:
virtual void Af() const {
cout << "A::Af()" << endl;
}
};
int main() {
typedef void (A::&
浏览 0提问于2011-08-30得票数 18
回答已采纳
5回答
我正在阅读有关元组的boost文档，发现了以下有效的元组实例化(A、B和C是一些用户定义的类)：
tuple<A, int(*)(char, int), B(A::*)(C&), C>
我不能理解第二个和第三个参数的类型。int(*)(char, int)和B(A::*)(C&)类型到底是什么？
浏览 0提问于2012-02-09得票数 1
回答已采纳
3回答
据我所知，基本类型是标量类型，数组是聚合类型，但是用户定义的类型呢？我根据什么标准将它们分为两类？
struct S { int i; int j };
class C { public: S s1_; S s2_ };
std::vector<int> V;
std::vector<int> *pV = &v;
浏览 2提问于2013-02-12得票数 34
回答已采纳
我有一个结构，它包含一个指向对象的空*指针和一个指向该对象类的某个方法的函数指针。我没有(也不能)拥有那个对象类的信息，所以我需要一个void*。我试图通过以下方式调用该方法：
object->*function(args)
当我尝试用msvc编译它时，我得到两个错误: C2296和C2297 C2296状态，即"->“无效，因为左操作数是无效的，因为它的"void”C2297状态相同，但是右操作数和"bool“类型是”bool“。
浏览 3提问于2021-02-24得票数 0
回答已采纳
有没有办法将指向CLR类型的指针分配给C# unsafe块中的void*？
var bar = 1;
var foo = new Foo();
unsafe
{
void* p1 = &bar;
void* p2 = &foo; // fails at compile time
}
或者，这只能使用C++/CLI实现：
System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
void* p1 = &sb;
找不到任何方法让它在C#中工作
浏览 0提问于2010-02-02得票数 2
回答已采纳
1回答
为什么下面的代码是错误的？模板接受哪种类型的参数？
class MyClass
{
int var;
};
template <MyClass a> struct s
{
};
int main()
{
MyClass var;
struct s<var>;
return 0;
}
浏览 0提问于2013-03-02得票数 0
回答已采纳
2回答
我有一门课叫Channel_thread。您可以猜到，它的一个函数是线程的，在这个函数中，我想根据情况调用另一个成员函数。这就是为什么我使用了一个成员函数数组。
下面是代码的样子：
Channel_thread.cpp：
#include <boost/bind.hpp>
#include "../include/Channel_thread.h"
Channel_thread::Channel_thread(Event_queue<std::deque<char>> *_serverQueue, Event_queue<std:
浏览 2提问于2018-07-23得票数 0
回答已采纳
1回答
我正在尝试理解函数指针，我有以下测试代码：
#include <iostream>
using namespace std;
class Test {
public:
void test_func() {
cout << "Test func called.";
}
};
void outer_test_func(Test &t, void (Test::*func)()) {
(t.*func)();
}
int main(int argc, char *argv[]) {
auto t
浏览 8提问于2017-12-06得票数 1
回答已采纳
如果我将大于1的值赋值给bool变量，那么存储在它中的值是什么？
bool mySwitchVariable = false;
mySwitchVariable = 3;
if(mySwitchVariable == 3){
cout << "3 is stored in the bool" << endl;
}
这是在规范中定义的吗？这种行为可以依赖于编译器吗？
谢谢
浏览 2提问于2015-03-11得票数 0
回答已采纳
7回答
是的，我见过和，但我还是不明白->*和.*在C++中是什么意思。
这些页面提供了有关运算符(如重载)的信息，但似乎没有很好地解释它们是什么。
什么是C++中的->*和.*，与->和.相比，您需要在什么时候使用它们
浏览 41提问于2011-07-06得票数 81
回答已采纳
1回答
让：
class A
{
typedef A (* func_t)( A a );
func_t * _func;
};
我必须按照什么顺序写这个，我需要什么前向声明(如果有的话)，这样它才能编译？
这是我真正的代码，如果需要的话：
class Value
{
public:
typedef Value (* func_t)( const std::vector< Value > & args );
private:
union
{
/// ...
func_t * _f;
}
_data;
浏览 2提问于2014-08-01得票数 0
回答已采纳
3回答
我试图理解带有正则函数的模板参数推导，指向正则函数的指针，成员函数和成员函数的指针。有人能解释为什么最后一行在没有独立问题的情况下会产生编译错误吗？
#include <iostream>
#include <type_traits>
struct A {
int fun(float, char) const&;
};
void standalone(int, char) {}
template <typename T>
void what(T &&) {
std::cout << __PRETT
浏览 6提问于2022-04-03得票数 0
回答已采纳
1回答
当我想在符号(::).It总是有一个尾随空格后获得宏中函数的地址时，就会产生这个问题，它会报告一个错误。
我在Mojave i386中使用了G++。
例如，我有一个类：
struct A{
void b();
};
还有一个宏：
#define ACC(name) &A::name
我用它来获取A::b的指针
void(*accab)() = ACC(b);
我会得到这样的错误：
error: cannot initialize a variable of type 'void (*)()' with an rvalue of type 'void (A::
浏览 1提问于2019-05-16得票数 1
回答已采纳
2回答
我认为C++规范说在引用函数时，函数前面的符号是不必要的，即
void bar();
void foo(void(*bar)());
foo(bar);
foo(&bar); // Same as above.
然而，我发现了一个不正确的例子。我试图对lambda进行模板专门化(仅针对单个参数)，以便能够访问lambda的返回参数和输入参数的类型。
// The ampersand in front of 'Fn::operator()' is necessary to make
// this code work.
template <typename La
浏览 5提问于2015-12-21得票数 4
回答已采纳
2回答
我试图从成员函数进行一些回调，一切都很好，直到我尝试使用一个从2个类派生的模板类作为回调对象时，我得到了以下错误：
error C2440: 'reinterpret_cast' : Pointers to members have different representations; cannot cast between them
这件事告诉我成员函数指针有不同的表示(doh！)
这些表示是什么？它们之间的区别是什么？
浏览 0提问于2012-12-14得票数 13
回答已采纳
减少指向数组第一个元素的指针是C17时未定义的行为。引用了C17的标准说法
C17 6.5.6/8
如果指针操作数和结果都指向同一个数组对象的元素，或者指向数组对象的最后一个元素，则计算值不会产生溢出；否则，行为将未定义。
这是最早定义的标准吗？这种操作是如何在早期的标准中定义的？以前是合法的吗？
浏览 2提问于2021-09-18得票数 0
回答已采纳
2回答
GCC 8.2.1和MSVC 19.20编译了下面的代码，但Clang 8.0.0和ICC 19.0.1没有这样做。
// Base class.
struct Base {};
// Data class.
struct Data { int foo; };
// Derived class.
struct Derived : Base, Data { int bar; };
// Main function.
int main()
{
constexpr int Data::* data_p{ &Data::foo };
constexpr int Derived::
浏览 1提问于2019-04-25得票数 7
回答已采纳
1回答
我正在做以下几件事：
获取具有3的成员函数指针，从派生类中平分。
将其转换为中的成员函数指针，基类具有0参数。
将其转换为、基类和、3个参数返回。
叫它吧。
(到目前为止)很好，但我应该留着它吗？
现行代码说明：
EventsWarehouse用于存储和调用事件：
#include <iostream>
#include <functional>
#include <unordered_map>
class EventsWarehouse
{
public:
typedef std::tuple<AView*, voi
浏览 1提问于2015-09-29得票数 3
回答已采纳
请验证我对指向成员的指针的理解是否正确。下面是一个示例类：
class T
{
public:
int *p;
int arr[10];
};
对于“标准”指针，下面的选项很常见：
int a = 1;
int *p1 = &a;
int *p2 = p1 (other notation: int *p2 = &*p1);
//The pointer p2 points to the same memory location as p1.
不可能对指向成员的指针执行上述操作：
int T::*pM = &(*T::p); // error
指
浏览 2提问于2013-11-06得票数 0
回答已采纳
最近，我遇到了一个有趣的enable_if用法版本，可以有条件地启用一个可读性稍好的函数，因为该函数的返回类型不是enable_if的一部分(参见cleaner_usage)：
#include <type_traits>
using maybe_integral = int /* = or float -- then won't compile */;
using return_type = int;
typename std::enable_if<std::is_integral<maybe_integral>::value, return_typ
浏览 2提问于2015-08-26得票数 4
回答已采纳
在C中，我有一个数组int A[20]。我有两个指针int *pi和int *pj分别指向两个条目A[i]和A[j]。我不认识i和j。我想知道i > j、j<i还是i==j。
我的想法是在pi和pj=A+j的基础上，通过比较pi = A + i和pj=A+j来实现这一点。我不知道i > j是否正确当且仅当pi>pj和i == j当且仅当pi==pj？谢谢!
浏览 4提问于2014-04-06得票数 1
回答已采纳
3回答
因此，我希望能够有一个静态的const编译时结构，它通过使用模板保存一些基于字符串的值。我只想要四个角色。我知道'abcd‘的类型是int，'ab'，'abc'，虽然'a’是char类型的，但它适用于template<int v> struct
我想做的是取一些const char，"abcd“的2,3,4,5的大小，并具有与使用'abcd‘相同的功能。注意，我不是指1,2,3或4，因为我期望空终止符。
cout << typeid("abcd").name() << endl;
浏览 7提问于2012-10-03得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
