0

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

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

例如

#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);
}

取决于它是否静态调用，代码可能会在非静态函数中略有改变，所以我们不能一直简单地使用静态函数，因为有时我们需要访问代码中其他地方使用的非静态成员。但是，大部分代码将保持不变。干杯

4

2 回答 2

5

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

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();
}
于 2012-11-30T14:20:22.870 回答
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，并且 if...暗示该函数没有明确的责任。

于 2012-11-30T15:17:55.563 回答