• String(C & C++ style) and array of string are completly different. Latter is fixed but format can grow.

• In addition, C++ strings are not null-terminated, so they can store null bytes,unlike C strings. Multiple copies of the same string share the same underlying buffer whenever possible. But because a string is mutable, new buffers are created as necessary.

• Differrence char array and char*

  1. First off, in function arguments, they are exactly equivalent: void foo(char *x); void foo(char x[]); exactly the same in all respects (note! this only applies if the brackets are empty)

  2. In other contexts, char * allocates a pointer, while char [] allocates an array. Where does the string go in the former case, you ask? The compiler secretly allocates a static anonymous array to hold the string literal. So:

     char *x = "Foo"; // is approximately equivalent to: static const char __secret_anonymous_array[] = "Foo"; char *x = (char *) __secret_anonymous_array;

     Note that you must not ever attempt to modify the contents of this anonymous array via this pointer; the effects are undefined (often meaning a crash): x[1] = 'O'; // BAD. DON'T DO THIS.

     Using the array syntax directly allocates it into new memory. Thus modification is safe: char x[] = "Foo"; x[1] = 'O'; // No problem.

  3. char text[10] = ""; // is equivalent to ==> char text[10] = { '\0' }; first explicit rest implicit

  4. char text[5] = { 'H', 'e', 'l', 'l', 'o' }; // No room for terminating zero

  5. char buf [10]; // ==> you will have random content in all the elements.

  6. char *cstr1 = "hello"; *(cstr1)='t';

  7. char *cstr2; //ERROR strcpy(cstr2, "hello"); *(cstr2)='t';

     // Allocate memory : char cstr2 = (char)malloc(strlen("hello")+1);

  8. char cstr3[100]; cstr3 = "hello"; // array name decays into a pointer to first value of array, It cant be assigned *(cstr3)='t';

     int a[100]; int b[100]; ... a = b; //error

  9. char cstr4[100] = "hello"; *(cstr4)='t';

  10. /*returns the length of the string without null char / int strlen(const char);

      /copies the 2nd string into the 1st/ char* strcpy(char*, const char*);

      /compares two strings/ int strcmp(const char*, const char*)

      /*char *a = strdup("stack overflow"); */ The strdup() function returns a pointer to a new string which is a duplicate of the string s. Memory for the new string is obtained with malloc(3), and can be freed with free(3).

      char nameArr[12] = "Alan Turing"; const char *namePtrConstChar = "Edsger W. Dijkstra"; char *ptr;

      // 1. copying - stack ptr = nameArr;

      // Error // nameArr = namePtrConstChar;

      // 2. copying - heap ptr = new char[strlen(nameArr) + 1]; strcpy(ptr, nameArr); delete [] ptr;

  11. std::string ::: -- s1<s2 Lexicographical comparison of string values; s1 or s2, but not both, can be a C-style string.

      s1==s2 Comparison of string values; s1 or s2, but not both, can be a C-style string.

  12. use the cin to get a numeric or a single word, but we need to use getline() for an input with spaces.

  13. To convert string to other data type : stringstream

  14. To reset stringstream: ss.str(""); ss.clear();

whats will change :p, or what it points to and what it will return

*p++

The postfix ++ and -- operators essentially have higher precedence than the prefix unary operators.

*p++ ==> *(p++) // p is increased but it return value p was pointer before(postfix)

Alternative : (*p)++ and ++*p