指向成员函数的指针的动态数组的语法问题
是指在C++中如何声明和使用一个动态数组，该数组的元素是指向成员函数的指针。
在C++中，声明一个指向成员函数的指针的动态数组的语法如下：
ReturnType (ClassName::*arrayName[]) (Parameters) = new ReturnType (ClassName::*) [arraySize];其中，ReturnType是成员函数的返回类型，ClassName是包含成员函数的类名，arrayName是指向成员函数指针的数组名称，Parameters是成员函数的参数列表，arraySize是数组的大小。
接下来，我们可以使用以下语法来访问动态数组中的元素（指向成员函数的指针）：
(arrayName[index]->*functionName)(arguments);其中，index是数组中元素的索引，functionName是成员函数的名称，arguments是传递给成员函数的参数。
下面是一个示例，演示了如何声明、使用指向成员函数的指针的动态数组：
#include <iostream>
class MyClass {
public:
void function1() {
std::cout << "Function 1" << std::endl;
}
void function2() {
std::cout << "Function 2" << std::endl;
}
};
int main() {
typedef void (MyClass::*FunctionPointer)();
FunctionPointer functionArray[] = { &MyClass::function1, &MyClass::function2 };
MyClass myObject;
for (int i = 0; i < sizeof(functionArray)/sizeof(FunctionPointer); i++) {
(myObject.*functionArray[i])();
}
return 0;
}此示例声明了一个名为functionArray的指向成员函数的指针的动态数组。然后，我们通过使用成员访问运算符（.）和指针运算符（->）来调用数组中的成员函数。
希望这个答案能满足你的需求。如有任何疑问，请随时提问。
相关·内容
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
回答已采纳
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
回答已采纳
3回答
我不明白如何为另一个结构中的结构数组动态分配内存。这就是我的问题所在。我有一个包含main的project.c文件，我还有另一个多项式.c文件，它处理所有的多边形操作，如添加项，将多项式乘以一个数字等。
这是多项式的头文件。h
typedef struct term{
int coeff;
int expo;
} TERM;
typedef struct polynomial {
int size;
// This needs to be changed to calloc.. not sure how within a struct
TERM terms[20];
}
浏览 1提问于2012-04-06得票数 1
回答已采纳
1回答
我有一个特定类类型的向量；
vector<Song> database;
和
class Song
{
public:
string getName() const;
string getSinger() const;
unsigned int getLength();
unsigned short getYear() const;
private:
char singer[51];
char name[51];
unsigned int length;
unsigned short year;
};
注意，向量不在
浏览 3提问于2014-12-27得票数 1
回答已采纳
2回答
有时，当通过引用传递数组时，模板函数可以方便地推导出常数数组的大小。
template <unsigned N>
void foo (int (&arg) [N]);
int data [3];
foo (data); // deduces N=3
现在，我想对指向数组成员的指针执行此演绎。这应该会给你一个主意
struct X
{
int inner_data_1 [3];
int inner_data_2 [4];
};
template <typename T, unsigned N>
void bar (int T ::* (&am
浏览 4提问于2013-08-12得票数 1
回答已采纳
2回答
我有一堆结构，每个结构都有一个“数组”成员和一个大小指示符：
struct S {
size_t num;
int arr[100];
};
struct V {
float array[10];
int size;
};
我想为每个结构创建机械手对象：
template <typename Type, typename ElementType, size_t N, typename SizeType>
struct StructManipulator {
Type* resource_;
ElementType Type::*el
浏览 0提问于2018-01-23得票数 2
回答已采纳
2回答
void foo();
class Foomatic() {
void bar();
void baz()
{
std::thread a(foo); // this compiles
std::thread b(Foomatic::bar, this); // this doesn't
std::thread c(&Foomatic::bar, this); // and this compiles
// ...
}
};
我知道指向成员函数的指针的正确语法是&Fooma
浏览 5提问于2016-12-25得票数 0
回答已采纳
3回答
我在创建指向类方法的函数指针时遇到了问题。我创建了一个指向非类方法的函数指针，它工作得很好。
int foo(){
return 5;
}
int main()
{
int (*pointer)() = foo;
std::cout << pointer();
return 0;
}
我试着应用它让类中的一个实例变量成为一个函数指针。
这是头文件。它声明变量方法将指向的私有方法Print。
class Game
{
public:
Game();
private:
void Print();
void (me
浏览 2提问于2016-05-02得票数 3
回答已采纳
2回答
我有一个具有私有数组和指针的类。我有3个构造函数，一个是复制构造函数，另一个是以指针数组为参数的复制构造函数。我是重载操作符，例如<<，ostream。当我将指向静态数组的指针传递给我的类时，我的程序运行良好。但是当我开始使用动态数组时，我的函数操作起来很奇怪，并输出一些疯狂的数据。在程序中，我应该做什么区别，这样操作符就可以同时处理静态数组和动态数组了？我有一个单独的函数，它创建动态数组随机()并返回指针，这是作为参数传递的。这是我的代码
浏览 4提问于2013-10-17得票数 0
回答已采纳
3回答
作为一个类的私有成员，我可以拥有一个函数指针数组吗？像这样，
class MyClass {
public: //public stuff
private:
void (*specficFunctions[16]) (void);
}
我特别不想使用functor或functionoid。
浏览 0提问于2010-07-23得票数 1
回答已采纳
假设SomeStruct定义为：
struct SomeStruct {
int member;
};
这些是什么意思？
&SomeStruct::member
int SomeStruct::*
我遇到这个，试着输出它的类型信息，但仍然找不出它的意思。下面是一个有用的例子：
#include <iostream>
#include <typeinfo>
using namespace std;
struct SomeStruct {
int member;
};
int main(int argc, const char *
浏览 4提问于2011-07-17得票数 1
回答已采纳
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回答
我是C++新手，我正在尝试创建一个具有构造函数的类，该构造函数动态地分配一个2D数组。我尝试在迭代器中使用for循环(比如: for(auto = arr.begin()；itr！= arr.end()；itr++))，发现不能对指针使用.begin()。
以下是我的代码：
class Myarray {
public:
Myarray(std::size_t a, std::size_t b) : row(a), col(b) {
ptr = new int* [row];
for (auto itr = ptr->begin(); itr !=
浏览 1提问于2020-06-03得票数 0
回答已采纳
我试图理解“指向成员的指针”是如何工作的，但并不是所有的事情对我来说都很清楚。
下面是一个示例类：
class T
{
public:
int a;
int b[10];
void fun(){}
};
以下代码稀释了问题并包含问题：
void fun(){};
void main()
{
T obj;
int local;
int arr[10];
int arrArr[10][10];
int *p = &local; // "standard" pointer
i
浏览 7提问于2013-10-23得票数 15
回答已采纳
2回答
当我需要指向类成员的指针时，我执行以下操作
struct MyStruct
{
int foo();
};
int (MyStruct::*p)() = &MyStruct::foo;
我的问题是为什么我需要使用& operator来获取地址，如果它是一个静态函数，那么它可能会被忽略。另外，我听说指向成员的指针并不是真正的指针，有人能澄清一下吗？
浏览 2提问于2011-12-20得票数 3
回答已采纳
我刚刚发现了一些C++代码(在，它使用了一种我以前从未见过的技术将类型添加到现有的类中：
class Testpm {
public:
void m_func1() { cout << "m_func1\n"; }
int m_num;
};
// Define derived types pmfn and pmd.
// These types are pointers to members m_func1() and m_num, respectively.
void (Testpm::*pmfn)() = &Testpm::m_func1
浏览 3提问于2009-10-29得票数 4
回答已采纳
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
回答已采纳
3回答
指向成员函数的指针的静态成员数组
、、、、
我试图在.cpp文件中定义一个属性，它应该是一个指向名为Hand的类的成员函数的指针数组。
数组和函数都是Hand的成员，并且数组是静态的(如果不应该，请纠正我)。
这就是我达到的目标：
static bool Hand::*(Hand::hfunctions)[] ()=
{&Hand::has_sflush,&Hand::has_poker,&Hand::has_full,&Hand::has_flush,
&Hand::has_straight,&Hand::has_trio,&Hand::has_2pair,&Hand::
浏览 6提问于2013-07-23得票数 2
回答已采纳
2回答
如何创建指向函数C++的指针线程
、、、、
我知道，为了在对象上创建方法线程，我可以这样做：
#include <thread>
using namespace std;
class Character
{
public:
void myFunction(int a){ /* */ }
void startThreadMyFunction(int a){
thread Mf1(&Character::myFunction, this, a);
}
};
我还知道，为了在我的类中有一个指向函数的指针，我可以这样做：
#include <thread>
using
浏览 0提问于2014-11-27得票数 2
回答已采纳
我在CS的第一年，在一个面向对象的course.We中，已经开始学习如何在C++中动态分配数组。我们现在正在解决很多问题，我们必须将一个对象推回一个已经动态分配的类数组中。
void functionInAClass(ClassName newObject){
ClassName *tmp = new ClassName [this->size+1];
for(int i = 0; i < this->size; i++){
tmp[i] = this->arr[i];
}
tmp [this->size++] =
浏览 3提问于2022-03-29得票数 -2
我有一个包含以下成员的结构Item。
struct Item{
char *name;
int price;
double weight;
};
具有以下成员的另一个结构Inventory。
struct Inventory{
struct Item **item;
int NUMITEMS;
};
我有一个函数addItem()，它以Inventory*作为参数。
void addItem(struct Inventory* i){
printf("Enter Name:");
scanf("%s",
浏览 3提问于2020-12-07得票数 2
回答已采纳
我在boost::thread上遇到了这个我无法解决的问题。
我有一个classX.h文件：
#include <boost/thread/thread.hpp>
class classX{
...
void startWork(void);
void doWork(void);
...
}
然后是一个.cpp文件：
...
void classX::startWork(){
boost::thread(&doWork);
}
void classX::doWork(){
...
}
我无法编译，我发现了错误(在我执行boost::thr
浏览 0提问于2012-06-10得票数 1
回答已采纳
1回答
函数指针(在类中)
、、、、
我试图使用函数指针(fnPtr)从另一个类方法(在本例中是构造函数)中引用类方法(fnEmpty)。
设置程序main.cpp是
#include <iostream>
#include "test.hpp"
int main(int argc, char* argv[]){
Test test;
return 0;
}
和test.hpp，它读取
#ifndef _test_h
#define _test_h
#include <iostream>
class Test {
private:
public:
浏览 2提问于2015-05-14得票数 3
我一直在想，为什么调用函数指针与调用成员函数指针在使用去引用操作符*方面有风格上的区别，即
void(*fptr)()=&f; // pointer to function f()
fptr(); // call f() via pointer to function
Foo foo; // instance of Foo
void (Foo::*fptr)()=&Foo::f; // pointer to member function f()
(foo.*fptr)(); // call foo.f() via pointer to member function
在第一
浏览 6提问于2014-06-21得票数 2
回答已采纳
3回答
C++结构中的多维数组引用
、、、、
如果我有一个像这样的多维数组：
int arr2d[2][3] = {{0,1,2}, {10,11,12}};
我可以将它传递给如下的函数：
void foobar(int arg[][3])
这不是通过值调用的，这是通过引用调用的，所以只是一个指向起始地址的指针，但是编译器仍然知道它是一个二维数组，我可以像在函数中一样访问它。
现在，同样的情况在结构中是如何工作的呢？
typedef struct {
int arr2d[][3];
} Foobar_t
首先给出的是：error: flexible array member in otherwise empty struct。我可以这
浏览 1提问于2017-09-04得票数 1
5回答
假设在C++中，我有以下代码：
class Foo {
private:
double* myData;
public:
Foo(double data[]) {
myData = data;
}
}
int main() {
double mainData[] = {1.0};
Foo myfoo(mainData);
}
据我所知，mainData在传递到Foo构造函数时被视为指针，因此行myData = data只分配指针地址。所以这里没有额外的内存，对吗？但是，Foo类是负责提供释放myData内存的析构函数吗?还是有一个实际指
浏览 1提问于2014-04-03得票数 1
回答已采纳
3回答
这也许是个愚蠢的问题，但我对它非常感兴趣。能否在纯C中实现操作符new、动态扩展数组、类？任何链接或代码示例将不胜感激。
浏览 6提问于2014-12-15得票数 1
回答已采纳
3回答
不允许成员函数的非指针类型定义？
、、、、
在得到的答案后，我发现有两种有效的方法来定义函数指针。
typedef void (Function) ();
typedef void (*PFunction) ();
void foo () {}
Function * p = foo;
PFunction q = foo;
我现在更喜欢Function * p而不是PFunction q，但显然这不适用于指向成员的指针函数。考虑一下这个人为的例子。
#include <iostream>
struct Base {
typedef void (Base :: *Callback) ();
浏览 44提问于2011-09-15得票数 17
回答已采纳
1回答
我偶然发现了，它说：
成员函数指针不是指针，非成员函数(包括静态成员函数)的指针是指针.
上面的引号似乎表明指向非静态成员函数的指针不是指针。
类似地，我读过
成员指针是与普通指针不同的类型类别。
，我的问题是，上面的引号在技术上(按照标准正式)是正确的吗？我的意思是我们用“指针”这个词来表示非静态的成员函数。但是，如果它们实际上不是指针，那么为什么首先使用“指针”这个术语呢？我的理解是，这是因为虽然“指向成员函数的指针”在许多方面与普通指针不同，但它们在某一方面仍然与普通指针相似，即它们指向某物(意思是保持地址)。
我也试过：
std::cout<<std::i
浏览 3提问于2022-05-09得票数 1
回答已采纳
2回答
假设我有一门课：
class A {
public:
A();
void myFunc();
};
然后在程序中的另一个点创建A类的实例，并尝试获取指向myFunc()的函数指针
A* a = new A;
//ATTEMPTS AT RETRIVING FUNCTION POINTER FOR A::MYFUNC
std::function<void()> fnptr = a->myFunc;
std::function<void()> fnptr(std::bind(A::myFunc, &a);
但这两次尝试都出现了错误“调用
浏览 4提问于2020-08-21得票数 2
回答已采纳
我正在尝试创建一个函数数组，这样我就可以用索引从数组中调用函数。我似乎找不出创建这个函数数组的括号、星号和括号。以下是我所拥有的：
void Game::getPawnMoves(int position, bool color, Move ** moveList) {
...
}
typedef void (*GetMoveFunction) (int, bool, Move **);
void Game::getLegalMoves(Move ** moveList) {
GetMoveFunction functions[] =
{
getPa
浏览 5提问于2022-02-28得票数 0
回答已采纳
3回答
考虑到以下代码：
typedef struct Tokens {
char **data;
size_t count;
} Tokens;
void freeTokens(Tokens *tokens) {
int d;
for(d = 0;d < tokens->count;d++)
free(tokens->data[d]);
free(tokens->data);
free(tokens);
tokens = NULL;
}
为什么我需要额外的：
free(tokens->data);
浏览 1提问于2017-07-27得票数 2
回答已采纳
1回答
我有一个std映射，它将字符串和函数指针组合在一起，如下所示： std::map<std::string, void (*)()> funcs {
{"print", &h::print},
{"scan", &h::scan_cmd},
{"connect", &h::stream},
{"stream", &h::stream}
}; 其中h是在其中初始化此map的封闭类： class h {
public:
voi
浏览 18提问于2019-02-21得票数 1
回答已采纳
2回答
可能重复：
最近，我一直在使用c++11中的新std：：线程库，我遇到了一个问题。当我试图将一个类函数传递到一个新线程时，它会给我一个错误(我现在没有确切的错误文本，因为我不在家里)我有一个这样的类
class A
{
void FunctA();
void FunctB();
void run()
{
std::thread t(FunctA);
std::thread r(FunctB);
}
}
我做错了什么？
浏览 1提问于2012-06-15得票数 20
回答已采纳
4回答
我有一个指向成员函数的指针列表，但我在尝试调用这些函数时遇到了困难。正确的语法是什么？
typedef void (Box::*HitTest) (int x, int y, int w, int h);
for (std::list<HitTest>::const_iterator i = hitTestList.begin(); i != hitTestList.end(); ++i)
{
HitTest h = *i;
(*h)(xPos, yPos, width, height);
}
我也尝试在这里添加成员函数。
std::list<HitTest
浏览 2提问于2013-02-11得票数 32
回答已采纳
1回答
我对这段代码有问题，因为编译器不允许我运行代码，因为
cannot convert 'void (Menu::*)(int)' to 'void (Menu::*)(int*)' in assignment.
我知道这个程序可以用正常的函数来执行。我读过一些关于typedef的东西，但我已经有一段时间没有编程了，我的英语也不是母语。代码有一些西班牙语单词，但不影响代码，我可以翻译，如果你想，但我认为这很容易理解。如果有人能帮我，我会很感激的。
#include "Menu.h"
#include<iostream>
using s
浏览 1提问于2016-03-27得票数 2
回答已采纳
1回答
指向方法问题的指针
、、、、
嗯，正如我在问题中所说的：
我的问题是: msvc++给我带来了错误。
如果我们有：
class A
{
bool one, two;
typedef void (A::* RunPtr)(int);
public:
RunPtr Run;
A() : one(false), two(false)
{
Run = &A::RunOff;
}
void SetOne(bool value)
{
one = value;
}
void SetTwo(bool value)
浏览 2提问于2021-08-07得票数 0
回答已采纳
我的c++实验室作业出了问题，我一直在搜索google，我尝试使用这种语法，它不会显示不合格的-Id编译错误。
typedef int (list::*find)(int val);
{
return 0;
}
头文件处的声明
class list {
public:
int *find(int val);
}
定义一个成员函数的语法是什么，它接受int并将指针返回到类的外部？
浏览 0提问于2018-02-02得票数 0
回答已采纳
我有这个定义struct的代码(传入是简单的struct)
#define FUNCS_ARRAY 3
struct func
{
void (AA::*f) (incoming *);
int arg_length;
};
func funcs[FUNCS_ARRAY];
然后在AA类主体中，我像这样定义指针数组：
funcs[0] = { &AA::func1, 4 };
funcs[1] = { &AA::func2, 10 };
funcs[2] = { &AA::func2, 4 };
当我尝
浏览 0提问于2012-07-21得票数 0
回答已采纳
我已经应用了一些基于搜索的解决方案，但问题仍然存在。非常感谢你的帮助。
error: must use '.*' or '->*' to call pointer-to-member function ...
源代码：
#include <stdio.h>
class A
{
public:
struct data;
typedef int (A::*func_t)(data *);
typedef struct data
{
int i;
func_t func;
}
浏览 0提问于2013-01-15得票数 0
回答已采纳
5回答
我试图了解数组在C++中是如何工作的。一些好的线索，但我有一个问题，我找不到答案是：
为什么可以声明没有大小的数组数据成员？我认为在C++中数组大小必须是编译时常数？
示例：
#include<iostream>
class Object{
public:
Object(std::size_t n){
for(std::size_t i = 0; i<n; ++i) { array[i] ='X'; }
//prints 0 because 'sizeof' is compile-time
浏览 10提问于2014-10-28得票数 0
回答已采纳
我想根据输入使用不同的函数来计算输出。但它说：(表式调用括号前的表达式必须具有(指针到-)函数类型)。
int (TestClass::* Gate_Func)(向量)；<<== --这是我启动的函数。
然后在这里: Gate_Func = &TestClass:: and；我可以用Gate_Func引用和函数
但是为什么output = Gate_Func(InputArr)；这个错误:表调用括号前的C++表达式必须具有(指针到-)函数类型。
#include <iostream>
#include <vector>
using namespac
浏览 13提问于2022-03-03得票数 0
回答已采纳
2回答
获取函数成员地址
、、、
有什么方法可以得到函数成员的确切地址吗？例如，我有：
struct foo
{
void print() { printf("bla bla bla"); }
};
//////////////////////////////////////////////////////////////
unsigned int address = foo::print;
浏览 0提问于2013-01-29得票数 2
回答已采纳
3回答
为了充分理解指针、值和引用是如何工作的，我正在编写一个基本的C++程序，试图篡改一些静态和动态数组，并准确地了解它们应该如何传入。
首先，我生成一个由3个元素组成的静态数组。然后，我将它传递到一个修改所有元素的函数中。然后，我将它传递给另一个具有稍微不同签名的函数，但也可以更改数组的值。
接下来，我生成一个动态大小的数组，通过引用将它传递到一个函数中，这样就可以修改这个动态大小数组中的所有值。
守则如下：
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace
浏览 7提问于2015-02-26得票数 1
回答已采纳
我已经为一个函数指针创建了一个类型定义，并且我正在尝试创建一个函数指针，并让它指向同一个类的成员函数：
typedef void(Controls::*KeyFunction)(void);
class Controls
{
public:
void OnKeyDown(Key key);
// Key Down Functions
void KeyLeftDown();
void KeyRightDown();
void KeyDownDown();
void KeyUpDown();
private:
static BOOL Ke
浏览 3提问于2016-08-17得票数 1
3回答
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
class A{
public:
A():n(4),d(6.6),f(2.7),s("hello my dear"){}
~A(){}
void printAll()
{
std::cout << this->n << "\n" << this->d <
浏览 0提问于2012-10-28得票数 1
4回答
继今天早些时候在这里问了一个和大量类似的主题问题之后，我在这里从stadard的角度来问这个问题。
struct Base
{
int member;
};
struct Derived : Base
{
int another_member;
};
int main()
{
Base* p = new Derived[10]; // (1)
p[1].member = 42; // (2)
delete[] p; // (3)
}
根据标准，(1)格式良好，因为Dervied* (这是新表达式的结果)可以隐式转换为Base* (C++11草案，第4.10/3节)：
浏览 5提问于2011-08-25得票数 11
回答已采纳
首先，我猜想k1的值不会在主空间中。但是后来我意识到数组是一个指针，所以有什么区别吗？我认为这是一样的，但也许任何人都可以找到一些其他的技术差异。也许更快的传递一个指针？
#include <iostream>
using namespace std;
void g(double [],int );
void f(double* [],int );
int main()
{
int n = 10;
double *k1, *k2;
k1 = new double[n];
k2 = new double[n];
g(k1,n);
浏览 7提问于2013-07-26得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
