In C, there's no (real, distinct type of) strings. Every C "string" is an array of chars, zero terminated.

Therefore, to extract a character c at index i from string your_string, just use

char c = your_string[i];

Index is base 0 (first character is your_string[0], second is your_string[1]...).

You can treat argv[1] as though it were an array of char (i.e., you can subscript it as argv[1][i]). You can pass it as an argument to any function that doesn't try to modify it (e.g., printf, strtol, strchr, etc.). You cannot write to it, though, so if you need to modify the contents for any reason (either directly or through a function like strtok or strcpy), you'll have to create a local copy and manipulate that.

If you are using C89 or earlier, use this method:

#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
  char *c = NULL;
  if (argc >= 2)
  {
    c = malloc(strlen(argv[1]) + 1);
    strcpy(c, argv[1]);
  }
  /**
   * Do stuff with c
   */
  free(c);
  return 0;
}

If you are using C99, you can use a VLA:

#include <string.h>

int main(int argc, char **argv)
{
  if (argc < 2)
    return 0;

  size_t len = strlen(argv[1]);
  char c[len+1];
  strcpy(c, argv[1]);
  /**
   * do stuff with c
   */
  return 0;
}

Just remember a few things:

1. The type of argv is char **, not char *[N]; similarly, the type of argv[i] is char *, not char [M]. In most circumstances it doesn't matter; you can use a subscript operator on a pointer as though it were an array (array subscripting is defined in terms of pointer arithmetic), but remember that pointers and arrays are not the same thing and are not always interchangeable;

2. The value of argv[argc] is always NULL;

3. Except when it is the operand of the sizeof or unary & operators or is a string literal being used as an initializer in a declaration, an expression of array type is converted ("decays") from "N-element array of T" to "pointer to T", and the value of the expression is the location of the first element;

4. C doesn't have a string data type as such; strings are represented as 0-terminated sequences of char. String literals such as "hello" are stored in such a way that they exist over the lifetime of the program, and you can access them via a pointer value; attempting to modify them results in undefined behavior (i.e., don't do that).

If you are concerned about the length of the string,reallocate the size of some dynamically allocated array accordingly.than you can store individual words in another array.check this out :

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

int GetWords(const char *String,char buffer[][255]);

int main(void)
{
    char buffer[30][255];

    const char *sentence = "Hello how are you";

    int num_of_words = GetWords(sentence,buffer);

    for( int n = 0 ; n < num_of_words ; n++ )
    {
        printf("word %d : %s\n" , n+1 , buffer[n]);
        //or do something else
    }

    return 0;
}

int GetWords(const char *String,char buffer[][255])
{
    int x = -1 , y = 0 , z = 0 ;

     size_t len = strlen(String) , n = 0 ;

    for( n = 0 ; n < len ; n++ )
    {
        y++;

        if( String[n] == ' ' /* || String[n] == ',' */ )
        {
            y = 0;
            z = 0;
        }

        if( y == 1 ) x++;

        if( y > 0 )
        {
            buffer[x][z] = String[n];
            z++;
            buffer[x][z] = '\0';
        }
    }

    //return number of words
    return (x+1);
}

Ok, i am shocked that no one really gave a good answer, now my turn. There are two cases;

1. A constant char array is good enough for you so you go with,

   const char *array = tmp.c_str();
   

2. Or you need to modify the char array so constant is not ok, then just go with this

   char *array = &tmp[0];
   

Both of them are just assignment operations and most of the time that is just what you need, if you really need a new copy then follow other fellows answers.