C++ 如何编程返回值取决于标志的函数，而不使用；如果“是”的话；？

我想创建一个类函数，如下面的概念代码

double function(){
  if(flag==true){
    "some process and return "
  } 
  else{
    "another process and return"
  }
}

其中，

标志

是类的布尔成员。 我想在不使用

if

的情况下创建此函数，因为我多次使用此函数。 要点是

我想对流程的两个案例使用相同的函数

我希望避免重新评估在一段时间内不会更改其值的标志

---

您可以将布尔值转换为int

int test(bool flag)
{
    return static_cast<int>(flag);
}

int not_test(bool flag)
{
    return static_cast<int>(!flag);
}

int测试（bool标志）
{
返回静态_cast（标志）；
}
int not_测试（布尔标志）
{
返回静态_cast（！flag）；
}

---

备注：发布此答案时，问题完全不同。

您可以将布尔值转换为整数

int test(bool flag)
{
    return static_cast<int>(flag);
}

int not_test(bool flag)
{
    return static_cast<int>(!flag);
}

int测试（bool标志）
{
返回静态_cast（标志）；
}
int not_测试（布尔标志）
{
返回静态_cast（！flag）；
}

---

备注：发布此答案时，问题完全不同。

类函数、标志和两种不同的行为？您可能应该创建两个派生类，删除标志，并使用

虚拟

函数来代替。

类函数、标志和两种不同的行为？您可能应该创建两个派生类，去掉标志，使用一个

virtual

函数。

如果您想根据

bool

的值调用两个不同成员函数中的一个，而不使用

If

或其他可能导致分支的函数，您可以创建一个包含两个函数指针的表，并通过使用

bool

进行索引，将其用于查找。如果只希望在标志值更改时执行此查找，则可以存储指向活动函数的指针，并且仅在设置了

标志时执行查找

成员函数也采用参数的示例：

#include <iostream>

class foo {
public:
    using func_t = double(foo::*)(double); // the type of the member functions

    double some(double x) { return x * 3.14159; }
    double another(double x) { return x * 3.14159 * 3.14159; }

    double function(double x) {      
        return (this->*active)(x); // "active" only changes when "flag" is set
    }

    void set(bool x) {
        flag = x;
        // lookup without "if" to set the active function:
        active = funcs[flag];
    }

private:
    // a static table of the functions to be called - only initialized once
    static constexpr func_t funcs[]{&foo::some, &foo::another};

    bool flag = false;
    func_t active = &foo::some;     // the active function
};

int main() {
    foo x;

    x.set(false);
    std::cout << x.function(2.) << '\n';

    x.set(true);
    std::cout << x.function(3.) << '\n';    
}

如果要根据
bool
的值调用两个不同成员函数中的一个，而不使用
If
或其他可能导致分支的函数，可以创建一个包含两个函数指针的表，并通过使用
bool
进行索引，将其用于查找。如果只希望在标志值更改时执行此查找，则可以存储指向活动函数的指针，并且仅在设置了
标志时执行查找

成员函数也采用参数的示例：

#include <iostream>

class foo {
public:
    using func_t = double(foo::*)(double); // the type of the member functions

    double some(double x) { return x * 3.14159; }
    double another(double x) { return x * 3.14159 * 3.14159; }

    double function(double x) {      
        return (this->*active)(x); // "active" only changes when "flag" is set
    }

    void set(bool x) {
        flag = x;
        // lookup without "if" to set the active function:
        active = funcs[flag];
    }

private:
    // a static table of the functions to be called - only initialized once
    static constexpr func_t funcs[]{&foo::some, &foo::another};

    bool flag = false;
    func_t active = &foo::some;     // the active function
};

int main() {
    foo x;

    x.set(false);
    std::cout << x.function(2.) << '\n';

    x.set(true);
    std::cout << x.function(3.) << '\n';    
}

说：“积分提升：类型
bool
可以转换为
int
，值
false
变为​<代码>0
​ 而且
true
变成
1
“-那么演员阵容就没有必要了。那么你就因为我明确的演员阵容而被否决了？据我所知，你应该总是把事情弄清楚，避免隐式强制转换。我没有对这个问题的任何答案投反对票-我只是提到，你建议的强制转换是不需要的，因为整数提升-比如在将
short
分配给
int
时。这样做的时候，人们也很少投球。说：“积分提升：类型
bool
可以转换为
int
，值
false
变为​<代码>0

​ 而且

true

变成

1

“-那么演员阵容就没有必要了。那么你就因为我明确的演员阵容而被否决了？据我所知，你应该总是把事情弄清楚，避免隐式强制转换。我没有对这个问题的任何答案投反对票-我只是提到，你建议的强制转换是不需要的，因为整数提升-比如在将

short

分配给

int

时。人们在这样做的时候也很少投。谢谢你的有用的评论。为了更清楚地解释这个问题，我编辑了这个问题。这个过程在现实中要复杂得多。你似乎想避免重新评估一个在一段时间内（你没有告诉我们）不会改变其值的标志？你还要编辑多少次这个问题？您不能使用两个类，一个用于标记为

true

，另一个用于

false

？您可以指定关于“在一段时间内不改变其值的标志”的任何保证吗？最后，测试布尔标志通常非常快，特别是当变量被缓存时，处理器甚至不会注意到它。找个地方进行优化，或者至少做一些性能测试！您可以向标志中添加一个观察者，并使用它调用正确的流程感谢您的有用评论。为了更清楚地解释这个问题，我编辑了这个问题。这个过程在现实中要复杂得多。你似乎想避免重新评估一个在一段时间内（你没有告诉我们）不会改变其值的标志？你还要编辑多少次这个问题？您不能使用两个类，一个用于标记为

true

，另一个用于

false

？您可以指定关于“在一段时间内不改变其值的标志”的任何保证吗？最后，测试布尔标志通常非常快，特别是当变量被缓存时，处理器甚至不会注意到它。找个地方进行优化，或者至少做一些性能测试！您可以向标志中添加一个观察者，并使用itI调用正确的进程。我猜OP希望能够随意更改对象的状态，然后根据其状态执行不同的操作，并且希望非常快地执行，以便省略测试。换句话说：据我所知，OP要求的是不可能的事情。所以，基本上，你提交了一个不适定问题的答案。如果OP真的希望能够随时更改对象的状态，那么虚拟函数并不能解决没有解决方案的问题。我猜OP希望能够随意更改对象的状态，然后根据其状态执行不同的操作，以及