switch-case a new way

This design pattern solves the problem of having to implement huge switch - case statements and makes dynamic switch - case not dependent on the number of cases.

• Download source - 85.3 Kb

Overview

This design pattern solves the problem of having to implement huge switch - case statements and makes dynamic switch - case not dependent on the number of cases.

Problem Description

If we have a program used for interpreting and executing commands, as like a Linux shell, and if we assume that we have 300 commands that needs to interpreted and executed, we would need to make a switch - case statement containing 300 cases, and what if we have more than 300 commands? Then, we would need more than 300 cases to handle all those commands. Here, we make a Design Pattern to solve this problem.

Design Pattern Steps

Step 1

Create for every case, only one separate function to handle all the logic of the case.

Collapse | Copy Code

void  HandleCase1 (int caseNumber) 
{
    printf(" The Handled Case Number Is = %d",caseNumber);
}
void  HandleCase2 (int caseNumber) 
{
    printf(" The Handled Case Number Is = %d",caseNumber);
}
void  HandleCase3 (int caseNumber) 
{
    printf(" The Handled Case Number Is = %d",caseNumber);
}

Put all of above function into a separate file and name it as HandleCases.cpp.

Step 2

Compile the above file as a shared object (dynamic library) using the following commands:

1. g++ -c -fpic HandleCases.cpp

   The above command generates an object file HandleCases.o.

2. g++ -shared -lc -o HandleCases.so HandleCases.o

   Now, we have a dynamic library containing all the case implementations.

Step 3

Create your main application where we will use this library instead of switch-cases.

1. Define a handle to our dynamic library.
   Collapse | Copy Code

   void* FunctionLib;

2. Define a pointer to the called function.
   Collapse | Copy Code

   void  (*Function)(int);

3. Open the dynamic library using the dlopen function.
   Collapse | Copy Code

   FunctionLib = dlopen("dynamic library path", RTLD_LAZY);

4. Get the desired function pointer using the dlsym function.
   Collapse | Copy Code

   Function =(void(*)(int))dlsym( FunctionLib, "HandleCase1");

5. Call this function using the above function pointer.
   Collapse | Copy Code

   (*Function)(1);

6. Finally, close the dynamic library.
   Collapse | Copy Code

   dlclose(FunctionLib);

Complete Code of Step 3

Collapse | Copy Code

#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h> // 
int main(int argc,char*argv[])
{
    // handle to Dynamic Libary
    void* FunctionLib; 

    // Pointer to called function
    void  (*Function)(int); 

    // Pointer to read the error
    char *error; 

    // Open Dynamic Loadable Libary with absolute path 
    FunctionLib = dlopen("HandleCases.so",RTLD_LAZY);
    
    if ((error = dlerror()) != NULL)
    {
        printf ("%s /n", error);
        exit(1);
    }

    // point to our function need to call
    Function =(void(*)(int))dlsym( FunctionLib, "HandleCase1"); 

    if ((error = dlerror()) != NULL) 
    {
        printf ("%s/n", error);
        exit(1);
    }

    // call our function
    (*Function)(1);

    // close Dynamic libary
    dlclose(FunctionLib); 

    return (0);
}

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.