char *str = "Hello"; 
*(++str) = 'A';  //I'm trying to change e to A. 

char* str = (char*) malloc(20);
strcpy(str,"hello");

int a[]={1,2}

int* a = (int*) malloc(2);

for(int i=0;i<2;i++)
  *(a+i) = i+1;

char* str = (char*) malloc(20);
strcpy(str,"hello");

str = (char*) malloc(len);

int array[4];

*(array+1) = 10;   //Set the second element of the array to 10.

char array[]="Hello";
char *parse;

parse = array;
parse++;
*parse = 'E';

#include <stdio.h>
int main()
{
  char *str; /* define a variable of type (pointer to char)       */

  printf("Initially:   str = %p\n", str);

  /* set the variable str to point to a string constant */
  str = "Hello";

  printf("After <str = \"Hello\";>   str = %p, *str = %c (0x%2x hex)\n", 
          str, *str, *str);
  printf("Heres the string pointed to by str: <%s>\n\n", str);

  /* increment the pointer (That's OK) */
  ++str;

  printf("After ++str: str = %p; *str = %c (0x%02x hex)\n", 
          str, *str, *str);
  printf("Heres the string now pointed to by str: <%s>\n\n", str);

  printf("  NOTE: the next statement is illegally storing a value into\n");
  printf("  memory associated with a string constant. At run time you\n");
  printf("  may see exception here (gcc says STATUS_ACCESS_VIOLATION).\n");
  printf("  The code generated by your compiler may actually do the\n"); 
  printf("  assignment and cheerfully proceed with the rest of the\n");
  printf("  program.\n");
  printf("  But, regardless of the results you get here, this is\n\n");
  printf("             WRONG, WRONG, WRONG!\n\n");

  *str = 'A';

  printf("After *str = 'A': str = %p, *str = %c (0x%02x hex)\n", 
         str, *str, *str);
  printf("Heres the string pointed to by str: <%s>\n", str);
  return 0;
}

#include <stdio.h>

void print_stuff1(char *);
void print_stuff2(char []);

int main()
{
  /*
   * The following declars that char_point is a variable of type
   * (pointer to char). The initialization sets the value of char_point
   * to the address of the string constant "Hello, World". The memory
   * where the string constant is stores is accessible (readable)
   * from this program, but the program is not allowed to write to
   * that area.
   */
  char *char_point = "Hello, World";

  /*
   * The following declares that char_array is an array of char. The
   * initialization does two things:
   * 1. Tells the compiler to allocate 3 chars for the array
   * 2. Puts 'H', 'i' and '\0' into three successive char locations,
   *    starting at &char_array[0]
   */
  char char_array[] = "Hi";

  /* 
   * The following declares that ch_array2 is an array of char.
   * The initialization does two things:
   * 1. Tells the compiler to allocate 3 chars for the array
   * 2. Puts the chars 'Y', 'o', and '\0' into three successive char
   *    locations, starting at &ch_array[0]
   */
  char ch_array2[] = {'Y', 'o', '\0'};

  /* The following declares that int_array is an array of int. The
   * initialization does two things:
   * 1. Tells the compiler to allocate two ints for the array
   * 2. Puts ints 1 and 2 into two successive int locations, starting
   *    at &int_array[0]
   */
  int int_array[] = {1, 2};

  /* The following declares that int_point is a variable of type
   * (pointer to int).
   * Now why can't we say something like the following?
    
     int *int_point = {1,2}

   * Because there's no such thing as an int array constant
   */
  int *int_point;

  printf("sizeof(char_point) = %d\n", sizeof(char_point));
  printf("sizeof(char_array) = %d\n", sizeof(char_array));
  
  print_stuff1(char_point);
  print_stuff1(ch_array2);
   
  print_stuff2(char_point);
  print_stuff2(ch_array2);
   
  return 0;
}


void print_stuff1(char *cp)
{
  printf("In print_stuff1: cp = %p, sizeof(cp) = %d, *cp = %c\n", 
          cp, sizeof(cp), *cp);
}

void print_stuff2(char ca[])
{
  printf("In print_stuff2: ca = %p, sizeof(ca) = %d, ca[0] = %c\n",
          ca, sizeof(ca), ca[0]);
}

char *str = "Hello";

int *a = {1,2};

int a[] = {1,2};