指向另一个对象的成员函数的指针

Question

我的情况是这样的：我有两个 classes：A，B。 A包含std::vector<B>，B需要A的函数指针来初始化自己的操作。

(我正在尝试用c++实现整数群和整数环数学结构)

完成此操作最安全的方法是什么？（我了解到给 B 一个指向 A 的指针会导致 A 发生意外行为。我试过了 here。）

现在我在我的电脑前，我将 post 我的代码库（我将 B 成员 class 设为 A，以尽量减少我必须输入的部分）：

A.h

#ifndef A_H
#define A_H

#include <vector>

class A
{
    public:
        A(int);
        static int defaultMultiply(int, int);
        int multiply(int, int);
        class B
        {
            public: 
                typedef int(*defaultMultiplication)(int, int);
                typedef int(A::*multiplication)(int, int);
                B();
                B(int, int, multiplication);
                B operator*(const B&);

            protected:
                int m, parentGroupSize;
                multiplication mult;
                defaultMultiplication defMult;

        };
    private: 
        int n; 
        std::vector<A::B> elements;

};

#endif

A.cpp

#include "A.h"

#include <new>

A::A()
{

}

A::A(int n)
 : n(n), elements(std::vector<A::B>(n))
{

}

int A::defaultMultiply(int x, int y) { return (x * y); }
// special multiplication: integer groups have integer addition modulo the group size as their multiplication
int A::multiply(int x, int y)
{
    int a = x % this->n, b = y % this->n;
    if (a < 0) a += this->n;
    if (b < 0) b += this->n;
    return ((a + b) % n);
}

A::B::B()
 : m(0), 
    parentGroupSize(0), 
    mult(0),
    defMult(&A::defaultMultiply) // right?
{

}

A::B::B(int m, int n, multiplication mult)
 : parentGroupSize(n), mult(mult), defMult(0)
{
    // this->m must be in [0, g->size() - 1], if n is larger than 1
    if (n > 1)
    {
        this->m = m % n;
        if (this->m < 0) this->m = n + this->m;
    }
    else
    {
        this->m = m;
    }
}

A::B A::B::operator*(const A::B& b)
{
    if (this->parentGroupSize == b.parentGroupSize)
    {
        if (this->mult)
        {
            return A::B::B((this->*mult)(this->m, b.m), this->parentGroupSize, &A::B::mult); // I tried using this->mult for last argument, but it wouldn't take it
        }
    }
    return A::B(); // or something similar
}

int A::B::val() const { return this->m; }

main.cpp

#include <iostream>

#include "A.h"

using namespace std;

int main()
{
    A(26);  // didn't implement any methods to get B's from A, since I am merely testing compilation. I'm trying for that ever-elusive MCVE with just this...
}

哦，我也得到以下错误：error: pointer to member type 'int (A::)(int, int)' incompatible with object type 'A::B'

Answer 1

你的问题不在于你将一个成员函数（作为参数）传递给一个与成员函数不同类型的对象的构造函数class类型；问题是您调用类型错误的成员函数。您得到的编译器错误实际上非常清楚：指向成员的指针必须与声明它的相同 class 类型一起使用（或派生类型），否则它将毫无意义。

请注意，内部 classes 不是 derived classes； B 对象不是 A 的特殊类型。（我想你已经意识到了这一点，但我想说清楚。）所以当你试图用类型为 B 的对象实例调用 A 的方法时，你要求的东西是完全没有意义。

所以，有两个选择：

使用指向成员B 的指针而不是指向成员A 的指针。从来没有任何理由用 A 类型的对象调用成员，所以不清楚为什么你认为 A 成员的指针在这里会有用。
使用非成员指针。请注意，您的 defaultMultiplication 类型已经是非成员函数。请注意，非成员仍然可以将 B 的实例作为参数；他们只是有一个更简单的语法。

指向另一个对象的成员函数的指针

Pointers to member functions of another object

c++

member-function-pointers