আমি কীভাবে সিটিতে স্ট্রিংগুলি `সুইচ` স্টেটমেন্ট ব্যবহার করে তুলনা করতে পারি?

Question 1

সি-তে এমন একটি switchনির্মাণ রয়েছে যা পরীক্ষার পূর্ণসংখ্যার মানের উপর ভিত্তি করে কোডের বিভিন্ন শর্তসাপেক্ষ শাখা সম্পাদন করতে সক্ষম করে, যেমন,

int a;
/* Read the value of "a" from some source, e.g. user input */
switch (a) {
  case 100:
    // Code
    break;
  case 200:
    // Code
    break;
  default:
    // Code
    break;
}

স্ট্রিং ভ্যালু অর্থাৎ ক এর জন্য একই আচরণ (যেমন তথাকথিত " if- elseমই" এড়ানো ) কীভাবে পাওয়া সম্ভব char *?

Question 2

যদি আপনি বোঝাতে চান তবে কীভাবে এর মতো কিছু লিখবেন:

// switch statement
switch (string) {
  case "B1": 
    // do something
    break;
  /* more case "xxx" parts */
}

তারপরে সি-তে মূল সমাধানটি হ'ল যদি-অন্য কোনও মই ব্যবহার করা হয়:

if (strcmp(string, "B1") == 0) 
{
  // do something
} 
else if (strcmp(string, "xxx") == 0)
{
  // do something else
}
/* more else if clauses */
else /* default: */
{
}

Question 3

আপনার যদি অনেকগুলি মামলা থাকে এবং একটি টন strcmp()কল লিখতে না চান তবে আপনি কিছু করতে পারেন:

switch(my_hash_function(the_string)) {
    case HASH_B1: ...
    /* ...etc... */
}

আপনাকে কেবল নিশ্চিত করতে হবে যে স্ট্রিংয়ের সম্ভাব্য মানগুলির সেটের মধ্যে আপনার হ্যাশ ফাংশনের কোনও সংঘাত নেই।

Question 4

সি তে এটি করার কোনও উপায় নেই অনেকগুলি ভিন্ন ভিন্ন পদ্ধতি রয়েছে। সাধারণত সবচেয়ে সহজ হল ধ্রুবকগুলির একটি সেট সংজ্ঞায়িত করা যা আপনার স্ট্রিংগুলিকে উপস্থাপন করে এবং ধ্রুবকটি পেতে স্ট্রিংয়ের সাহায্যে এক নজর করা:

#define BADKEY -1
#define A1 1
#define A2 2
#define B1 3
#define B2 4

typedef struct { char *key; int val; } t_symstruct;

static t_symstruct lookuptable[] = {
    { "A1", A1 }, { "A2", A2 }, { "B1", B1 }, { "B2", B2 }
};

#define NKEYS (sizeof(lookuptable)/sizeof(t_symstruct))

int keyfromstring(char *key)
{
    int i;
    for (i=0; i < NKEYS; i++) {
        t_symstruct *sym = lookuptable[i];
        if (strcmp(sym->key, key) == 0)
            return sym->val;
    }
    return BADKEY;
}

/* ... */
switch (keyfromstring(somestring)) {
case A1: /* ... */ break;
case A2: /* ... */ break;
case B1: /* ... */ break;
case B2: /* ... */ break;
case BADKEY: /* handle failed lookup */
}

এটি করার জন্য আরও কার্যকরী উপায় অবশ্যই রয়েছে। আপনি যদি আপনার কীগুলি বাছাই করে রাখেন তবে আপনি বাইনারি অনুসন্ধান ব্যবহার করতে পারেন। আপনি একটি হ্যাশ টেবিলও ব্যবহার করতে পারেন। এই জিনিসগুলি রক্ষণাবেক্ষণ ব্যয়ে আপনার কর্মক্ষমতা পরিবর্তন করে change

Question 5

এটি করার জন্য আমার পছন্দসই পদ্ধতিটি হ্যাশ ফাংশনের মাধ্যমে ( এখান থেকে ধার করা )। চর * এর সাথে কাজ করার সময়ও এটি আপনাকে একটি স্যুইচ স্টেটমেন্টটির দক্ষতা কাজে লাগাতে দেয়:

#include "stdio.h"

#define LS 5863588
#define CD 5863276
#define MKDIR 210720772860
#define PWD 193502992

const unsigned long hash(const char *str) {
    unsigned long hash = 5381;  
    int c;

    while ((c = *str++))
        hash = ((hash << 5) + hash) + c;
    return hash;
}

int main(int argc, char *argv[]) {
    char *p_command = argv[1];
    switch(hash(p_command)) {
    case LS:
        printf("Running ls...\n");
        break;
    case CD:
        printf("Running cd...\n");
        break;
    case MKDIR:
        printf("Running mkdir...\n");
        break;
    case PWD:
        printf("Running pwd...\n");
        break;
    default:
        printf("[ERROR] '%s' is not a valid command.\n", p_command);
    }
}

অবশ্যই, এই পদ্ধতির জন্য প্রয়োজনীয় সমস্ত সম্ভাব্য গৃহীত গৃহস্থালীর জন্য হ্যাশ মানগুলি আগাম গণনা করা দরকার। আমি মনে করি না এটি কোনও ইস্যুর খুব বেশি; তবে, যেহেতু স্যুইচ বিবৃতি নির্ধারিত নির্ধারিত মানগুলিতে কাজ করে। হ্যাশ ফাংশনটির মাধ্যমে চরটি পাস করতে এবং তাদের ফলাফলগুলি আউটপুট করার জন্য একটি সাধারণ প্রোগ্রাম তৈরি করা যেতে পারে। এই ফলাফলগুলি তখন ম্যাক্রোর মাধ্যমে সংজ্ঞায়িত করা যেতে পারে যেমন আমি উপরে করেছি।

Question 6

আমি মনে করি এটির সর্বোত্তম উপায় হ'ল কার্যকারিতা থেকে 'স্বীকৃতি' আলাদা:

struct stringcase { char* string; void (*func)(void); };

void funcB1();
void funcAzA();

stringcase cases [] = 
{ { "B1", funcB1 }
, { "AzA", funcAzA }
};

void myswitch( char* token ) {
  for( stringcases* pCase = cases
     ; pCase != cases + sizeof( cases ) / sizeof( cases[0] )
     ; pCase++ )
  {
    if( 0 == strcmp( pCase->string, token ) ) {
       (*pCase->func)();
       break;
    }
  }

}

Question 7

আমি সি তে স্ট্রিংগুলিতে স্যুইচটি সম্পাদনের জন্য একটি শিরোনাম ফাইল প্রকাশ করেছি, এতে একটি ম্যাক্রোর সমষ্টি রয়েছে যা একটি সুইচ-জাতীয় আচরণের নকল করার জন্য স্ট্রিংকে () বা (অনুরূপ) কলটি আড়াল করে। আমি এটি লিনাক্সে কেবল জিসিসি দিয়ে পরীক্ষা করেছি, তবে আমি নিশ্চিত যে এটি অন্যান্য পরিবেশকে সমর্থন করার জন্য অভিযোজিত হতে পারে।

সম্পাদনা: অনুরোধ অনুসারে কোডটি এখানে যুক্ত করুন

এটি শিরোনাম ফাইলটি আপনার অন্তর্ভুক্ত করা উচিত:

#ifndef __SWITCHS_H__
#define __SWITCHS_H__

#include <string.h>
#include <regex.h>
#include <stdbool.h>

/** Begin a switch for the string x */
#define switchs(x) \
    { char *__sw = (x); bool __done = false; bool __cont = false; \
        regex_t __regex; regcomp(&__regex, ".*", 0); do {

/** Check if the string matches the cases argument (case sensitive) */
#define cases(x)    } if ( __cont || !strcmp ( __sw, x ) ) \
                        { __done = true; __cont = true;

/** Check if the string matches the icases argument (case insensitive) */
#define icases(x)    } if ( __cont || !strcasecmp ( __sw, x ) ) { \
                        __done = true; __cont = true;

/** Check if the string matches the specified regular expression using regcomp(3) */
#define cases_re(x,flags) } regfree ( &__regex ); if ( __cont || ( \
                              0 == regcomp ( &__regex, x, flags ) && \
                              0 == regexec ( &__regex, __sw, 0, NULL, 0 ) ) ) { \
                                __done = true; __cont = true;

/** Default behaviour */
#define defaults    } if ( !__done || __cont ) {

/** Close the switchs */
#define switchs_end } while ( 0 ); regfree(&__regex); }

#endif // __SWITCHS_H__

এবং এইভাবে আপনি এটি ব্যবহার:

switchs(argv[1]) {
    cases("foo")
    cases("bar")
        printf("foo or bar (case sensitive)\n");
        break;

    icases("pi")
        printf("pi or Pi or pI or PI (case insensitive)\n");
        break;

    cases_re("^D.*",0)
        printf("Something that start with D (case sensitive)\n");
        break;

    cases_re("^E.*",REG_ICASE)
        printf("Something that start with E (case insensitive)\n");
        break;

    cases("1")
        printf("1\n");
        // break omitted on purpose

    cases("2")
        printf("2 (or 1)\n");
        break;

    defaults
        printf("No match\n");
        break;
} switchs_end;

Question 8

স্ট্রিং অনুসন্ধানটি দ্রুত সম্পাদন করার একটি উপায় রয়েছে। অনুমান: যেহেতু আমরা একটি স্যুইচ স্টেটমেন্টের কথা বলছি, আমি ধরে নিতে পারি যে রানটাইম চলাকালীন মানগুলি পরিবর্তন হবে না।

ধারণাটি হ'ল সি স্ট্ডলিবের কিউসোর্ট এবং বিসার্ক ব্যবহার করা।

আমি xtofl এর কোডে কাজ করব।

struct stringcase { char* string; void (*func)(void); };

void funcB1();
void funcAzA();

struct stringcase cases [] = 
{ { "B1", funcB1 }
, { "AzA", funcAzA }
};

struct stringcase work_cases* = NULL;
int work_cases_cnt = 0;

// prepare the data for searching
void prepare() {
  // allocate the work_cases and copy cases values from it to work_cases
  qsort( cases, i, sizeof( struct stringcase ), stringcase_cmp );
}

// comparator function
int stringcase_cmp( const void *p1, const void *p2 )
{
  return strcasecmp( ((struct stringcase*)p1)->string, ((struct stringcase*)p2)->string);
}

// perform the switching
void myswitch( char* token ) {
  struct stringcase val;
  val.string=token;
  void* strptr = bsearch( &val, work_cases, work_cases_cnt, sizeof( struct stringcase), stringcase_cmp );
  if (strptr) {
    struct stringcase* foundVal = (struct stringcase*)strptr;
    (*foundVal->func)();
    return OK;
  }
  return NOT_FOUND;
}

Question 9

উপরের ফিমিউমের উত্তরে যুক্ত করতে, যদি আপনার স্ট্রিং সর্বদা দুটি অক্ষর হয় তবে আপনি দুটি 8-বিট অক্ষরের মধ্যে একটি 16-বিট ইন্টি তৈরি করতে পারেন - এবং এটি স্যুইচ করতে পারেন (নেস্টেড সুইচ / কেস স্টেটমেন্টগুলি এড়াতে)।

Question 10

অন্যের সাথে স্ট্রিংয়ের তুলনা করার জন্য আমরা যদি-অন্য সিঁড়ি থেকে পালাতে পারি না। এমনকি নিয়মিত স্যুইচ-কেসটি অভ্যন্তরীণভাবে যদি অন্য কোনও মই হয় (পূর্ণসংখ্যার জন্য)। আমরা কেবল স্ট্রিংয়ের জন্য স্যুইচ-কেসটি অনুকরণ করতে চাই, তবে অন্য-মই যদি কখনও প্রতিস্থাপন করতে পারি না। স্ট্রিং তুলনার জন্য অ্যালগরিদমগুলির সেরাটি স্ট্রিংসিএমপি ফাংশন ব্যবহার থেকে বাঁচতে পারে না। চরিত্র অনুসারে চরিত্রের তুলনা করার অর্থ কোনও মিল নেই যতক্ষণ না পাওয়া যায়। সুতরাং if-other মই এবং strcmp ব্যবহার অনিবার্য।

ডেমো

এবং স্ট্রিংগুলির জন্য স্যুইচ-কেস অনুকরণ করার জন্য এখানে সহজ ম্যাক্রোগুলি রয়েছে।

#ifndef SWITCH_CASE_INIT
#define SWITCH_CASE_INIT
    #define SWITCH(X)   for (char* __switch_p__ = X, int __switch_next__=1 ; __switch_p__ ; __switch_p__=0, __switch_next__=1) { {
    #define CASE(X)         } if (!__switch_next__ || !(__switch_next__ = strcmp(__switch_p__, X))) {
    #define DEFAULT         } {
    #define END         }}
#endif

এবং আপনি তাদের হিসাবে ব্যবহার করতে পারেন

char* str = "def";

SWITCH (str)
    CASE ("abc")
        printf ("in abc\n");
        break;
    CASE ("def")              // Notice: 'break;' statement missing so the control rolls through subsequent CASE's until DEFAULT 
        printf("in def\n");
    CASE ("ghi")
        printf ("in ghi\n");
    DEFAULT
        printf("in DEFAULT\n");
END

আউটপুট:

in def
in ghi
in DEFAULT

নীচে নেস্টেড সুইচ ব্যবহার:

char* str = "def";
char* str1 = "xyz";

SWITCH (str)
    CASE ("abc")
        printf ("in abc\n");
        break;
    CASE ("def")                                
        printf("in def\n");
        SWITCH (str1)                           // <== Notice: Nested SWITCH
            CASE ("uvw")
                printf("in def => uvw\n");
                break;
            CASE ("xyz")
                printf("in def => xyz\n");
                break;
            DEFAULT
                printf("in def => DEFAULT\n");
        END
    CASE ("ghi")
        printf ("in ghi\n");
    DEFAULT
        printf("in DEFAULT\n");
END

আউটপুট:

in def
in def => xyz
in ghi
in DEFAULT

এখানে বিপরীত স্ট্রিং সুইচ, যেখানে আপনি CASE শৃঙ্খলে একটি পরিবর্তনশীল (ধ্রুবকের চেয়ে) ব্যবহার করতে পারেন:

char* str2 = "def";
char* str3 = "ghi";

SWITCH ("ghi")                      // <== Notice: Use of variables and reverse string SWITCH.
    CASE (str1)
        printf ("in str1\n");
        break;
    CASE (str2)                     
        printf ("in str2\n");
        break;
    CASE (str3)                     
        printf ("in str3\n");
        break;
    DEFAULT
        printf("in DEFAULT\n");
END

আউটপুট:

in str3

Question 11

এটি আমি সাধারণত এটি করি।

void order_plane(const char *p)
{
    switch ((*p) * 256 + *(p+1))
    {
        case 0x4231 : /* B1 */
        {
           printf("Yes, order this bomber.  It's a blast.\n");
           break;
        }

        case 0x5354 : /* ST */
        {
            printf("Nah.  I just can't see this one.\n");
            break;
        }

        default :
        {
            printf("Not today.  Can I interest you in a crate of SAMs?\n";
        }
    }
}

Question 12

এইভাবে আপনি এটি করেন। না সত্যিই না.

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>


 #define p_ntohl(u) ({const uint32_t Q=0xFF000000;       \
                     uint32_t S=(uint32_t)(u);           \
                   (*(uint8_t*)&Q)?S:                    \
                   ( (S<<24)|                            \
                     ((S<<8)&0x00FF0000)|                \
                     ((S>>8)&0x0000FF00)|                \
                     ((S>>24)&0xFF) );  })

main (void)
{
    uint32_t s[0x40]; 
    assert((unsigned char)1 == (unsigned char)(257));
    memset(s, 0, sizeof(s));
    fgets((char*)s, sizeof(s), stdin);

    switch (p_ntohl(s[0])) {
        case 'open':
        case 'read':
        case 'seek':
            puts("ok");
            break;
        case 'rm\n\0':
            puts("not authorized");
            break;
        default:
            puts("unrecognized command");  
    }
    return 0;
}

Question 13

যদি এটি 2 বাইট স্ট্রিং হয় তবে আপনি এই কংক্রিটের উদাহরণের মতো কিছু করতে পারেন যেখানে আমি ISO639-2 ভাষা কোডগুলিতে স্যুইচ করি।

    LANIDX_TYPE LanCodeToIdx(const char* Lan)
    {
      if(Lan)
        switch(Lan[0]) {
          case 'A':   switch(Lan[1]) {
                        case 'N': return LANIDX_AN;
                        case 'R': return LANIDX_AR;
                      }
                      break;
          case 'B':   switch(Lan[1]) {
                        case 'E': return LANIDX_BE;
                        case 'G': return LANIDX_BG;
                        case 'N': return LANIDX_BN;
                        case 'R': return LANIDX_BR;
                        case 'S': return LANIDX_BS;
                      }
                      break;
          case 'C':   switch(Lan[1]) {
                        case 'A': return LANIDX_CA;
                        case 'C': return LANIDX_CO;
                        case 'S': return LANIDX_CS;
                        case 'Y': return LANIDX_CY;
                      }
                      break;
          case 'D':   switch(Lan[1]) {
                        case 'A': return LANIDX_DA;
                        case 'E': return LANIDX_DE;
                      }
                      break;
          case 'E':   switch(Lan[1]) {
                        case 'L': return LANIDX_EL;
                        case 'N': return LANIDX_EN;
                        case 'O': return LANIDX_EO;
                        case 'S': return LANIDX_ES;
                        case 'T': return LANIDX_ET;
                        case 'U': return LANIDX_EU;
                      }
                      break;
          case 'F':   switch(Lan[1]) {
                        case 'A': return LANIDX_FA;
                        case 'I': return LANIDX_FI;
                        case 'O': return LANIDX_FO;
                        case 'R': return LANIDX_FR;
                        case 'Y': return LANIDX_FY;
                      }
                      break;
          case 'G':   switch(Lan[1]) {
                        case 'A': return LANIDX_GA;
                        case 'D': return LANIDX_GD;
                        case 'L': return LANIDX_GL;
                        case 'V': return LANIDX_GV;
                      }
                      break;
          case 'H':   switch(Lan[1]) {
                        case 'E': return LANIDX_HE;
                        case 'I': return LANIDX_HI;
                        case 'R': return LANIDX_HR;
                        case 'U': return LANIDX_HU;
                      }
                      break;
          case 'I':   switch(Lan[1]) {
                        case 'S': return LANIDX_IS;
                        case 'T': return LANIDX_IT;
                      }
                      break;
          case 'J':   switch(Lan[1]) {
                        case 'A': return LANIDX_JA;
                      }
                      break;
          case 'K':   switch(Lan[1]) {
                        case 'O': return LANIDX_KO;
                      }
                      break;
          case 'L':   switch(Lan[1]) {
                        case 'A': return LANIDX_LA;
                        case 'B': return LANIDX_LB;
                        case 'I': return LANIDX_LI;
                        case 'T': return LANIDX_LT;
                        case 'V': return LANIDX_LV;
                      }
                      break;
          case 'M':   switch(Lan[1]) {
                        case 'K': return LANIDX_MK;
                        case 'T': return LANIDX_MT;
                      }
                      break;
          case 'N':   switch(Lan[1]) {
                        case 'L': return LANIDX_NL;
                        case 'O': return LANIDX_NO;
                      }
                      break;
          case 'O':   switch(Lan[1]) {
                        case 'C': return LANIDX_OC;
                      }
                      break;
          case 'P':   switch(Lan[1]) {
                        case 'L': return LANIDX_PL;
                        case 'T': return LANIDX_PT;
                      }
                      break;
          case 'R':   switch(Lan[1]) {
                        case 'M': return LANIDX_RM;
                        case 'O': return LANIDX_RO;
                        case 'U': return LANIDX_RU;
                      }
                      break;
          case 'S':   switch(Lan[1]) {
                        case 'C': return LANIDX_SC;
                        case 'K': return LANIDX_SK;
                        case 'L': return LANIDX_SL;
                        case 'Q': return LANIDX_SQ;
                        case 'R': return LANIDX_SR;
                        case 'V': return LANIDX_SV;
                        case 'W': return LANIDX_SW;
                      }
                      break;
          case 'T':   switch(Lan[1]) {
                        case 'R': return LANIDX_TR;
                      }
                      break;
          case 'U':   switch(Lan[1]) {
                        case 'K': return LANIDX_UK;
                        case 'N': return LANIDX_UN;
                      }
                      break;
          case 'W':   switch(Lan[1]) {
                        case 'A': return LANIDX_WA;
                      }
                      break;
          case 'Z':   switch(Lan[1]) {
                        case 'H': return LANIDX_ZH;
                      }
                      break;
        }
      return LANIDX_UNDEFINED;
    }

LANIDX_ * অ্যারে ইনডেক্স করার জন্য ধ্রুবক পূর্ণসংখ্যা হিসাবে ব্যবহৃত হয়।

Question 14

অল্প পরিসীমা এবং আকারের (চারার) == 1 ধরে নেওয়া, আপনি এটি করতে পারেন (এরকম কিছু মাইক্রোমের পরামর্শ দিয়েছিল)।

char* txt = "B1";
int tst = *(int*)txt;
if ((tst & 0x00FFFFFF) == '1B')
    printf("B1!\n");

এটি বিই ক্ষেত্রে সাধারণীকরণ করা যেতে পারে।

Question 15

ফাংশন পয়েন্টারগুলি এটি করার একটি দুর্দান্ত উপায়, যেমন

result = switchFunction(someStringKey); //result is an optional return value

... এটি স্ট্রিং কী দ্বারা সেট করা একটি ফাংশনকে কল করে (প্রতি ক্ষেত্রে একটি ফাংশন):

setSwitchFunction("foo", fooFunc);
setSwitchFunction("bar", barFunc);

প্রাক-বিদ্যমান হ্যাশম্যাপ / টেবিল / অভিধান প্রয়োগ যেমন খাশ, সেই পয়েন্টারটির অভ্যন্তরের কোনও ফাংশনে ফিরিয়ে দিন switchFunction()এবং এটি সম্পাদন করুন (বা কেবল এটি থেকে ফিরে switchFunction()আসুন এবং এটি নিজে চালনা করুন)। মানচিত্রের প্রয়োগটি যদি এটি সংরক্ষণ না করে তবে কেবলমাত্র uint64_tপরিবর্তে একটি পয়েন্টারের পরিবর্তে আপনি একটি কাস্টম ব্যবহার করুন ।

Question 16

হাই আপনার এই ক্ষেত্রেটি থাকলে এটি সহজ এবং দ্রুত উপায়:

[দ্রুত মোড]

int concated;
char ABC[4]="";int a=1,b=4,c=2;            //char[] Initializing
ABC<-sprintf(ABC,"%d%d%d",a,b,c);          //without space between %d%d%d
printf("%s",ABC);                          //value as char[] is =142
concated=atoi(ABC);                        //result is 142 as int, not 1,4,2 (separeted)

//now use switch case on 142 as an integer and all possible cases

[বর্ণিত মোড]

উদাহরণস্বরূপ: আমার অনেক মেনু রয়েছে, প্রথম মেনুতে প্রতিটি পছন্দ আপনাকে ২ য় মেনুতে নিয়ে যায়, ২ য় মেনু এবং ২ য় মেনুতে একই জিনিস b তবে বিকল্পগুলি ডিফেরেন্ট যাতে আপনি জানেন যে ব্যবহারকারীটি ফিনালিকে বেছে নিয়েছে। উদাহরণ:

মেনু 1: 1 ==> মেনু 2: 4 ==> মেনু 3: 2 (...) পছন্দটি 142. অন্যান্য ক্ষেত্রে: 111,141,131,122 ...

সলিউশন: এ-তে প্রথম 1 ম, খ-এ 2 য়, সি তে তৃতীয় স্টোর। a = 1, খ = 4, সি = 2

 char ABC[4]="";
 ABC<-sprintf(ABC,"%d%d%d",a,b,c);              //without space between %d%d%d
 printf("%s",ABC);                              //value as char[]=142

      //now you want to recover your value(142) from char[] to int as  int value 142

 concated=atoi(ABC);                            //result is 142 as int, not 1,4,2 (separeted)