Question

我们的代码中有一个静态类函数，它包含大量代码。在最初使用此代码但仍然使用的情况下，不能创建类的实例，因此它是静态的。现在我们的代码库中的其他地方需要此函数的功能，其中已经创建了类的实例。

在不制作相同函数的非静态和静态版本的情况下，无论如何我们都可以创建一个非静态函数，它包含可以在没有类实例初始化的地方使用静态函数轮询的所有代码，同时允许使用其他地方的实际实例调用它。

例如

#include <iostream>

class Test
{
public:
    Test(){};
    ~Test(){};
    void nonStaticFunc(bool calledFromStatic);
    static void staticFuncCallingNonStaticFunc();
};

void Test::nonStaticFunc(bool calledFromStatic)
{
    std::cout << "Im a non-static func that will house all the code" << std::endl;
    if(calledFromStatic)
    // do blah
    else
    // do blah
}

void Test::staticFuncCallingNonStaticFunc()
{
    std::cout << "Im a static func that calls the non static func that will house all `the code" << std::endl;
    nonStaticFunc(true);
}

int main(int argc, char* argv[])
{
   // In some case this could be called as this     
   Test::staticFuncCallingNonStaticFunc();

   // in others it could be called as 
   Test test;
   test.nonStaticFunc(false);
}

根据静态调用是否静态调用代码可能会在非静态函数中稍微改变，所以我们不能一直使用静态函数，因为有时我们需要访问代码中其他地方使用的非静态成员。但是，大多数代码仍然是相同的。干杯

Answer 1

将公共部分重构为类方法并从两个方法中调用它。当然，您无法在公共部分方法中访问非静态成员。

class Test
{
public:
    Test(){};
    ~Test(){};
    void nonStaticFunc();
    static void staticFunc();
private:
    static void commonParts();
};

void Test::commonParts()
{
    std::cout << "Im a static func that will house all common parts" << std::endl;
    // do common stuff
}

void Test::nonStaticFunc()
{
    std::cout << "Im a non-static func that will call the common parts and do other things then" << std::endl;
    commonParts();
    // do non-static stuff
}

void Test::staticFunc()
{
    std::cout << "Im a static func that will call the common parts and then do other things" << std::endl;
    commonParts();
    // do static stuff
}

int main(int argc, char* argv[])
{
   // In some case this could be called as this     
   Test::staticFunc();

   // in others it could be called as 
   Test test;
   test.nonStaticFunc();
}

Answer 2

我倾向于不提供解决方法，因为我认为这是一个应该修复的设计问题，而不是被黑客攻击。

无论如何，您可以将公共代码分解为一个静态函数，该函数获取指向对象的指针。从非静态成员调用它时，您传递this，而在从静态函数调用时，您不传递该对象：

class test {
   void impl( test* p ) {
       // ...
       if (p) {           // we have an object: use it
          p->dosomething();
       }
   }
public:
   void nonStaticVersion() {
      impl(this);
   }
   static void staticVersion() {
      impl(0);
   }
};

但你应该重新考虑你是否真的想这样做。想一想impl做什么，给它一个名字。如果您找不到简单的名称并简要说明它的作用，请重构，直到您拥有执行易于描述的简单任务的函数。请注意，如果函数的描述开始具有条件，那就是代码气味（即根据Z执行X或Y，如果...... 暗示该函数没有明确的责任

从静态函数调用非静态类函数

2 个答案: