You're also confused about the difference between char and char[]. A char represents a *single* character, such as 'a'. You cannot store multiple characters in a char, you need to use an array of char (aka char[] or char*), with a NULL terminator. "Hello" is equivalent to 'H','e','l','l','o','\0' and is therefore SIX bytes long (that's why you get +1's all over C strings).

So c1.insert(TaxLic); is fine.
void insert(char); needs changing to void insert(char*);
and void cqueue :: insert(char TaxLic) to void cqueue :: insert(char* TaxLic)

Now, a[rear]=TaxLic; is a lot more complicated and this particular enhancement should be left alone until you're more familiar with C. However if you want to proceed anyway... The variable a needs to be an array of char* - read that correctly - a must contain multiple pointers to char. So the definition of a will need to be char *a[MAX]. Or if you're happy to use fixed length strings, let's say 10 characters each, it would be char a[MAX][10] (or char a[10][MAX] - I can never remember if char[x][y] defines x strings of y length or y strings of x length; usually a core dump sorts it out...).

If you're going to use variable length strings then char *a[MAX] is fine, BUT you will need to manage the memory pointed to by each entry in a. I suggest you initialise each member of a in the constructor to zero and use that to determine whether or not any given element points to valid memory.

So a[rear]=TaxLic; needs to become:
Code:
{
  if (a[rear]) { free(a[rear]); a[rear]=0; }
  a[rear]=malloc(strlen(TaxLic]+1);
  strcpy(a[rear],TaxLic);
}
You will also need to alter the code for any other references to a. This will show you the need to use more sensible variable names; search the code for any reference to "a" and you will soon get annoyed with hitting Search Again over and over and hitting a's embedded in other words and variables. If a was instead called even something simple like "arr" this would be a lot easier.

So k=a[front]; won't work either and deletion() will need substantially rewriting to solve this one, IF it really needs to return what it has deleted. If you don't really need the deleted value to be returned then just change k=a[front]; to { free(a[front]); a[front]=0; }, change the return type of deletion to void and remove the return statement.

If you really want to return something then define deletion to return a char*, malloc the memory in deletion and return the pointer to that memory, BUT you must remember to free() that pointer somewhere otherwise you will have a memory leak because NOTHING - not even obvious stuff - is done automatically for you in C.
Code:
char *cqueue::deletion()
{
  char *k=malloc(strlen(a[front])+1);
  strcpy(k,a[front]);
  // other code
  free(a[front]);
  a[front]=0;
  // other code
  return k;
}

// then maybe something like:

case 2 : 
{ 
  char *val=c1.deletion();
  cout<<"Deleted Element :"<<val<<endl;
  free(val);
  break;
}
If you're using fixed length strings then cqueue::display() doesn't get much simpler unfortunately. You can't return a stack variable to the calling function because the stack frame is invalid when the function returns, so you can't do
Code:
char *cqueue::display()
{
  char k[10];
  //...
  return k;
}
and instead k should be defined by the caller, for example:
Code:
case 2 : 
{ 
  char k[10];
  c1.deletion(k);
  cout<<"Deleted Element :"<<val<<endl;
  free(val);
  break;
}

// and:

void cqueue::display(char *k)
{
  // other code
  // change k=a[front]; to:
  strcpy(k,a[front]);
  // other code
}