呼び出すたびに、交互に処理をする関数の実装方法

Question

実装方法に悩んでいるので助言をお願いしたいです。

引数で処理を分ける関数があるとします

func(int tmp)
{
    if(0 == tmp)
    {
        printf("A\n");
    }
    else
    {
        printf("B\n");
    }
}

この二つの関数を、ある一つの関数を呼び出すだけで呼び出すたびに交互に処理をする関数を作成したいと思っています。

func_call_AorB
{
    // 前回がfunc(1)ならfunc(0)を実行
    // 前回がfunc(0)ならfunc(1)を実行
}

func(0)とfunc(1)を使うかどうかの設定値も持っており
それによっても処理を分岐しなくてはなりません、片方が使用しない設定なら
片方の関数を呼び続けるようにしたいです。
両方の設定がfalseになることはありません、また設定値は途中で変わることはありません

func_call_AorB
{
    if(true == use_0)
    {
        // 前回の実行がfunc(1)か、func(1)を使わない設定ならfunc(0)を実行
    }
    if(true == use_1)
    {
        // 前回の実行がfunc(0)か、func(0)を使わない設定ならfunc(1)を実行
    }
}

フラグを複数使ってごり押しのコードを書けば実現できそうなのですが
できるだけスマートに書けないかと思い質問させていただきました

よろしくお願いいたします

※質問が間違っていたため修正しました

###追記
シンプルに文章が長くなりすぎないようにと考えて質問した結果
本来やりたい事から離れてた上に、回答者さんにも混乱をあたえてしまうことになってしまったことをお詫びします。
皆様回答ありがとうございました

Comments

[yuba]

「funcAとfuncBを使うかどうかの設定値」データはどこにどんな形で保持されていて、それは途中で変わってしまう可能性があるものでしょうか。

また、複数のスレッドが func_call_AorB を呼び出すことは想定されているのでしょうか。

また、そもそもそんなことをしたい目的はどんなものなのでしょうか。

[episteme]

で、初回はどーすんの?

Answer 1

イメージになりますが、こんなのはどうでしょうか。

int get_func_param() {
    if (/*0も1も使えない*/) return null;
    if (/*初回or前回が1かつ0が使える*/) return 0;
    if (/*前回が0かつ1が使える*/) return 1;
    return null;
}

func(get_func_param());

Answer 2

ある一つの関数を呼び出すだけで呼び出すたびに交互に処理をする

これだけなら、

void func(){
    static bool sel = false;
    if(sel){
        printf("B\n");
    }else{
        printf("A\n");
    }
    sel = sel ^ true; //exorで反転
}

あたりで十分な気はしますがしかし

func(0)とfunc(1)を使うかどうか

さらに

片方が使用しない設定なら片方の関数を呼び続けるようにしたい

この三つの機能を一つの関数に持たせて引数で切り替えよう、という事に無理があると思います。

void func0(){
    printf("A\n");
}
void func1()
{
    printf("B\n");
}
enum Mode
{
    FLIP,
    HOLD,
    FUNC0,
    FUNC1
};

void func(Mode md)
{
    static bool sel = false;
    swich(md){
        case FLIP:
            sel = sel ^ 1;
            break;
        case HOLD:
            break;
        case FUNC0:
            sel = true;
            break;
        case FUNC1:
            sel = false;
            break;
    }
    if (sel)
    {
        func0();
    }
    else
    {
        func1();
    }
}

とか。う～ん、ムリヤリ感満載ですね。

Comments

[tuyudaku]

>この三つの機能を一つの関数に持たせて引数で切り替えよう、という事に無理があると思います
やはり無理やり感は出てしまいますよね...
C++をしっかりと活用したことが無いため、私の知らない標準ライブラリで
とても便利なものがあるのでは...!?
とも期待していたのですが、そうあまくは無いですねｗ

FLIP、HOLDの考え方はとても参考になりました
作成中のプログラムでも活かせそうな気がするので勉強になりました！

回答ありがとうございました

Answer 3

func_call_AorB(){
    static int aorb=0;
    if(use_0 && use_1){
        aorb = 1 - arob;
        func(arob);
    }else{
        func(use_1);
    }
}

ですかね。aorbをboolにするのもあり。

Comments

[otn]

use_0とuse_1の、
・どっちも真なら、交互に呼び出す。
・片方しか真でないなら、真の方の値で呼び出す（trueが1であることを利用）。

[otn]

use_0やuse_1がboolでなくて0と1以外の値を取り得るなら、func(use_1)じゃなくて、func(!use_0)ですかね。こっちの方が良かったか。

[tuyudaku]

なるほど...
人によって考え付く実装方法がいろいろありとても勉強になります
こんな分かりにくい質問で回答していただきありがたいです

今回の質問は質問をシンプルにしすぎて
本来やりたいこととはかけ離れてしまったことに気付いたため
また別の質問をしたいと思います。見かけた際はよろしくお願いいたします

回答ありがとうございました

Answer 4

関数オブジェクトを切り替える方法はどうでしょう。

#include <functional>
#include <iostream>

void funcA(void);
void funcB(void);

namespace {
    bool useFuncA = true;
    bool useFuncB = true;
    std::function<void(void)> func = funcA;
}

void funcA(void) {
    std::cout << "funcA\n";
    if(useFuncB) func = funcB;
}
void funcB(void) {
    std::cout << "funcB\n";
    if(useFuncA) func = funcA;
}

すみません、根本的に私の質問が間違っていて

違う関数ではなく同じ関数で実引数を交互に変えるというものでした..

スマートかは分かりませんが、一つの案として。ほぼ変わってないですね。

#include <iostream>
#include <functional>
#include <string>

void funcA(void);
void funcB(void);

namespace {
    bool useParamA = true;
    bool useParamB = true;
    std::function<void(void)> func = funcA;
}

void funcImpl(const std::string& arg) {
    std::cout << arg << "\n";
}
void funcA(void) {
    funcImpl("A");
    if(useParamB) func = funcB;
}
void funcB(void) {
    funcImpl("B");
    if(useParamA) func = funcA;
}

Comments

[tuyudaku]

>関数オブジェクトを切り替える方法はどうでしょう
おぉ...なるほど！！
と思ったのですが

すみません、根本的に私の質問が間違っていて
違う関数ではなく同じ関数で実引数を交互に変えるというものでした..
本当に申し訳ないです

質問を修正します...

回答ありがとうございました！

Answer 5

そんなに入り組んだ話でもないようですし，
func()に渡すべき引数を要素数２の配列で持ってしまうのが楽かと思います．

下記★記載の設定初期化方法を適切に用意する必要があります．
（いつ設定が決定されるのかわからないですが）

• {0,0} あるいは {1,1} に設定すれば，一方だけがずっと続く（片方を禁止する）
• {0,1} あるいは {1,0} に設定すれば「交互」になる

namespace
{
  int arg_for_func[2] = { 0, 1 };  //←★この配列の内容を初期化する手段を適切に設ける
  int next_index_of_arg_for_func = 0;  //←必要であれば，こいつを0に初期化する手段もあると良いかも
}

//呼び出す毎に
//func()の引数が変わる関数
void TheFunction()
{
  //func()の呼び出し
  func( arg_for_func[ next_index_of_arg_for_func ] );

  next_index_of_arg_for_func = ( next_index_of_arg_for_func + 1 )%2;
}

Answer 6

そりゃ同じ関数を呼び出して、その中で交互に関数を呼び出せばいいはなしになりますが、
そんでいいのかな？

そもそもの、あなたのやりたいことがなになのか、を聞いてくれるほうがいいかとおもいますが。

Comments

[tuyudaku]

たしかに、できるだけシンプルに質問しようとしすぎて
逆に分かりにくくなってしまっていますね...

ただ、根本的にやりたいことを明確に書くと少し長くなりそうで困っております...
もう少し文章を練り直して見ます

回答ありがとうございました

[y_waiwai]

まあ、やりたいことが言えないというならそんだけのはなしですわな。
他人に聞く段階ではないということで。

まあ、ご自分で頑張ってください。