1

誰かが次のように個々の関数を各人に個別に作成したとします。

void John_age(void);
void Tom_age(void);
void Kate_age(void);
void Cathy_age(void);

...................................

彼らの年齢を決定します。

今、次のように、人の名前だけを使用してこれらの関数を呼び出す関数を作成したいと思います。

void age(char* NAME){...}

その人「NAME」の特定の機能を呼び出す。

void NAME_age(void);

C++またはCでそれを行う簡単な方法はありますか? よろしくお願いします。ありがとう。

私がマイクロコントローラに使用しているIDEは、void X_functionName(void);個々のピンごとに実行可能な機能をフォーマットで作成しますX。そのため、のような関数を使用して簡単に呼び出すためのより一般的なアプローチを探していましたvoid customName(const char* X)。

4

7 に答える 7

6

とても簡単です。名前から年齢関数へのマップを作成します。
typedef は関数ポインタをより簡単にし、静的ローカル マップは関数ポインタを 1 回だけ初期化してから結果を「キャッシュ」します。順序付けられていないマップは、この種のものに最適です。

C++11:

void age(const std::string& NAME){
    static const std::unordered_map<std::string, void(*)()> age_lut = {
            {"John",John_age},
            {"Tom",Tom_age},
            {"Kate",Kate_age},
            {"Cathy",Cathy_age},
        };
    return age_lut.at(Name); //throws std::out_of_range if it doesn't exist
}

C: (ここでは怠け者なので、C++ のようなハッシュの代わりに線形マップを使用します)

typedef void(*)() get_age_func_type; 
typedef struct {
    const char* name;
    get_age_func_type func;
} age_lut_type;

age_lut_type age_lookup_table[] = {
            {"John",John_age},
            {"Tom",Tom_age},
            {"Kate",Kate_age},
            {"Cathy",Cathy_age},
        };
const unsigned age_lookup_table_size = 
        sizeof(age_lookup_table)/sizeof(age_lut_type);

bool age(char* NAME){
    bool found = false;
    //if you have a large number of functions, 
    //sort them in the initialization function, and 
    //use a binary search here instead of linear.
    for(int i=0; i<age_lookup_table_size ; ++i) {
        if (stricmp(age_lookup_table[i], NAME)==0) {
            age_lookup_table[i].func();
            found = true;
            break;
        }
    }
    return found;
}

このコードはすべて私の頭の中で思い浮かんだものであり、おそらくそのままではコンパイルできません。

実際には、個人ごとに関数を持たず、代わりにデータを使用することを強くお勧めします。絶対に必要な場合は、文字列の代わりに列挙を使用してそれらを識別します。

于 2013-07-08T17:36:33.357 に答える
3

C++ では、std::map関数ポインターのを作成します。

typedef void (*Age_Function_Pointer)(void); // Establish synonym for function syntax.

typedef std::map<std::string, Age_Function_Pointer> Lookup_Table;

unsigned int age(char const * name)
{
  static bool   table_is_initialized = false;
  Lookup_Table  name_func_map;
  if (!table_is_initialized)
  {
     name_func_map["Cathy"] = Cathy_age;
     name_func_map["Kate"]  = Kate_age;
     name_func_map["Tom"]   = Tom_age;
     name_func_map["John"]  = John_age;
  }
  std::string name_key = name;
  Lookup_Table::const_iterator iterator = name_func_map.find(name_key);
  unsigned int persons_age = 0U;
  if (iterator != name_func_map.end())
  {
     persons_age = (*(iterator.second))();
  }
  return persons_age;
}

同様に C では、関数ポインタのルックアップ テーブルを作成できます。

struct Table_Entry_t
{
    char const *   name;
    Age_Function_Pointer p_func;
};

struct Table_Entry_t Age_Lookup_Table[] =
{
    { "Cathy", Cathy_age},
    { "Kate", Kate_age},
    { "Tom", Tom_age},
    { "John", John_age},
};
const unsigned int NUMBER_OF_ENTRIES =
    sizeof(Age_Lookup_Table) / sizeof(Age_Lookup_Table[0]);

unsigned int age(char const * person_name)
{
   unsigned int person_age = 0;
   unsigned int i = 0;
   for (i = 0; i < NUMBER_OF_ENTRIES; ++i)
   {
      if (strcmp(person_name, Age_Lookup_Table[i]) == 0)
      {
        person_age = (Age_Lookup_Table[i].p_func)();
        break;
      }
   }
   return person_age;
}
于 2013-07-08T17:39:18.600 に答える
3

最も単純だがスケーラブルではないソリューションは、次のようなものです（C ++で）：

void age(std::string name) {
    if( name == "John" ) {
        John_age();
    }
    else if( name == "Tom" ) {
        Tom_age();
    }
    else if( name == "Kate" ) {
        Kate_age();
    }
    // and so on
}

シンプルでスケーラブルですが、厄介な解決策は、マクロを使用することです。

#define AGE(name) name##_age()

引用符なしで呼び出す：

AGE(John);
于 2013-07-08T17:41:26.873 に答える
2

C++またはCでそれを行う簡単な方法はありますか

C++ では、名前のマングリングがひどいため (std::unordered_map<void (*)(), std::string>すべての可能な関数を作成しない限り)、いいえ。しかし、C では次のことができます。

void *hndl = dlopen(NULL, RTLD_NOW); // or dlopen(RTLD_DEFAULT, RTLD_NOW)
void (*fptr)(void) = dlsym(hndl, "func_name");
fptr();
于 2013-07-08T17:21:44.600 に答える
2

あなたが何をしているのかがわかったので、それをしないことを真剣にお勧めします. しかし、本当にやりたいのであれば、有効性は疑わしいものの、ポリモーフィズムは C++ のより興味深い方法かもしれません。perl/python スクリプトを使用して、次のような漠然としたヘッダーを生成します。

struct pin_type {
    virtual ~pin_type () {}
    virtual void name()=0; 
    virtual void age()=0; 
};

struct John_type : public pin_type {
    void name() {John_name();}
    void age() {John_age();}
};
John_type& John() {static John_type John_; return John_;}

struct Tom_type : public pin_type {
    void name() {Tom_name();}
    void age() {Tom_age();}
}
Tom_type & Tom() {static Tom_type Tom_; return Tom_;}

... thousands you say?

そして、ここにあなたの通常のコード：

pin* get_pin_by_name(const char* name) {
     //look up table of some sort, described by other answers
}

int main() {
    pin_type * pin = John(); //instant, and probably allows inlining next calls
    pin->age(); //same speed and size as function pointer
    pin->name(); //but we avoid multiple lookups
    pin = get_pin_by_name("Tom"); //runtime names can be ok too
    pin->name(); //calls Tom_name();
}
于 2013-07-08T18:59:16.340 に答える
0

あなたは、動的プログラミング言語の一般的な機能である何かを説明していますが、C や C++ はそうではありません。

std::unordered_map<void (*)(), std::string>C++ では、H2CO3 と Thomas Matthews によって提案されているように使用することをお勧めします。

最小限のオーバーヘッドで、if-else 構造を使用できます。このソリューションは C で動作するはずです。

void age(char* NAME){
    void (*fp)(void);

    if      (strcmp(NAME, "John") == 0) { fp = John_age; }
    else if (strcmp(NAME, "Tom")  == 0) { fp = Tom_age; }
    /* ... additional cases ... */
    else { /* handle bad input */ }

    fp();  /* calls the appropriate age function */
}
于 2013-07-08T17:39:29.380 に答える