C++ 为什么我可以通过静态指针调用非静态函数？

我认为我不能使用静态指针调用非静态函数，因为我认为静态指针属于整个类，而非静态函数属于特定对象。但不知何故，我成功了，不知道为什么会这样

这是我的密码：

#include <cstdio>

class B
{
public:
    void show(int aValue);
};

//B.cpp
void B::show(int aValue)
{
    if (aValue == 100)
        printf("This is the desired value");
    else
        printf("This is not the desired value");
}

class A
{
private:
    static B* mUpdater;
public:
    static int function1();
};

B* A::mUpdater = new B();
int A::function1()
{
    int final = 100;
    mUpdater->show(final); // mUpdater is a static pointer, show is a non-static function
    return 1;
}


int main()
{
    return !A::function1();
}

#包括
B类
{
公众：
无效显示（国际视听）；
};
//B.cpp
void B:：show（int aValue）
{
如果（aValue==100）
printf（“这是所需的值”）；
其他的
printf（“这不是所需的值”）；
}
甲级
{
私人：
静态B*mUpdater；
公众：
静态int函数1（）；
};
B*A:：mUpdater=newb（）；
inta:：function1（）
{
int final=100；
mUpdater->show（final）；//mUpdater是静态指针，show是非静态函数
返回1；
}
int main（）
{
return！A:：function1（）；
}

代码运行并打印“这是所需的值”。但我有点困惑，因为我认为代码无法运行。这是因为我将一个特定对象的地址分配给指针，以便它可以工作吗？或者不管在哪种情况下，静态指针都可以调用非静态函数

任何想法都将受到极大的赞赏

我认为我不能使用静态指针调用非静态函数，因为我认为静态指针属于整个类，而非静态函数属于特定对象

静态成员指针属于“整个”类，因此所有实例（或其他静态成员函数）都可以访问它。但一旦他们访问它，他们访问的只是一个指针

具体地说，如果指针指向同一类的实例，那么这些函数也可以访问该指针指向的对象的私有成员。

（假设

B

继承自

A

（请参见问题的注释）。）

static

成员函数意味着不能使用类/对象的

this

指针。在

A:：function1（）

中，不使用

此

指针。相反，您可以调用实际实例（属于

B

）的一个函数，该函数可能是静态的，也可能不是静态的。是否通过静态/非静态指针/引用访问该实例并不重要。因此，您的使用是有效的

---

然而，您的代码相当混乱。您的

show（）

函数无论如何都不使用该类的任何变量，因此它可能是静态的。另外，使用指向另一个类型为

B

的对象的指针从

a

的静态成员函数调用非静态成员函数似乎是不可信的。当您希望使用

a

的某个实例的数据时，您可能会遇到这样一种情况，即使用

B

的某个实例的数据。

如果我理解正确，您是在问

static B* mUpdater;

具体来说，你会惊讶于

mUpdater->show(final);

是合法C++。< /P> 重要的是要理解，上面的

static

关键字指的是

mUpdater

，而不是它所指的内容。也就是说，有一个指针，由所有

a

共享，指向类

B

的单个对象

当您编写

mUpdater->show（）

时，会取消引用

A:：mUpdater

以访问单个

B

对象，并调用该

B

的

show（）

方法

您可以进一步简化您的示例，从而更容易从周围的干扰中找出您的问题：

#include <cstdio>

struct B
{
    void show() {
        printf("This is B::show()\n");
    }
};

struct A
{
    static B *worker;
    static void f() {
        worker->show();
    }
};

B* A::worker = new B();


int main()
{
    A::f();
    return 0;
}

#包括
结构B
{
无效显示（）{
printf（“这是B:：show（）\n”）；
}
};
结构A
{
静态B*工人；
静态空隙f（）{
worker->show（）；
}
};
B*A:：worker=newb（）；
int main（）
{
A：：f（）；
返回0；
}

请提供更完整的A类和B类定义。

mUpdater

是

静态的

这一事实允许您使用

A:：mUpdater

，而无需

A

的实例。它在后面的用法是相同的。在你的例子中，你没有调用类A的show函数，而是调用mUpdater函数，它是指向类型B的对象的指针。如果没有类B的明确定义，你的问题就无法正确回答。我不得不删除两条注释，因为我有点困惑，请将其设置为MCVE。目前还不清楚。

A

是否继承自

B

？我相信您的误解是“不能使用静态指针调用非静态函数”。如果没有任何对象可以“使用”调用非静态函数（即，执行

show（1）；

内部

function1

将不起作用），则不能调用非静态函数。只要你有一个有效的对象，该对象如何或在哪里存储并不重要。非常感谢你的回答！我只是简化了代码，我只是想展示一下结构。实际上，show函数中还有一些其他参数。我不知道你为什么认为B继承自A，实际上它们没有继承关系哦，我知道……对不起，我犯了一个错误，

show（）

属于B类，我将修改我的代码