Showing posts with label Pointer Arithmetic. Show all posts
Showing posts with label Pointer Arithmetic. Show all posts

Saturday, 8 August 2015

Let us dive into part four of our lesson on pointers and strings. You can revise the previous three parts here, here and here.

Fundamentals of Characters and Strings

          Character constant
        Integer value represented as character in single quotes
        'z' is integer value of z
          122 in ASCII

          String
        Series of characters treated as single unit
        Can include letters, digits, special characters  +, -, * ...
        String literal (string constants)
          Enclosed in double quotes, for example:
                                            "I like C++"
        Array of characters, ends with null character '\0'
        String is constant pointer
          Pointer to string’s first character
        Like arrays

          String assignment
        Character array
          char color[] = "blue";
        Creates 5 element char array color
        last element is '\0'
        Variable of type char *
          char *colorPtr = "blue";
        Creates pointer colorPtr to letter b in string “blue”
        “blue” somewhere in memory
        Alternative for character array
          char color[] = { ‘b’, ‘l’, ‘u’, ‘e’, ‘\0’ };

          Reading strings
        Assign input to character array word[ 20 ]
                               cin >> word 
          Reads characters until whitespace or EOF
          String could exceed array size
                                            cin >> setw( 20 ) >> word;
          Reads 19 characters (space reserved for '\0')

          cin.getline
          Read line of text
          cin.getline( array, size, delimiter );
          Copies input into specified array until either
          One less than size is reached
          delimiter character is input
          Example
                             char sentence[ 80 ];
                             cin.getline( sentence, 80, '\n' );

String Manipulation Functions of String-handling Library

          String handling library <cstring> provides functions to
        Manipulate string data
        Compare strings
        Search strings for characters and other strings
        Tokenize strings (separate strings into logical pieces)





          Copying strings
        char *strcpy( char *s1, const char *s2 )
          Copies second argument into first argument
          First argument must be large enough to store string and terminating null character
        char *strncpy( char *s1, const char *s2,   size_t n )
          Specifies number of characters to be copied from string into array
          Does not necessarily copy terminating null character




          Concatenating strings
        char *strcat( char *s1, const char *s2 )
          Appends second argument to first argument
          First character of second argument replaces null character terminating first argument
          Ensure first argument large enough to store concatenated result and null character
        char *strncat( char *s1, const char *s2, size_t n )
          Appends specified number of characters from second argument to first argument
          Appends terminating null character to result



          Comparing strings
        Characters represented as numeric codes
          Strings compared using numeric codes
        Character codes / character sets
          ASCII
          “American Standard Code for Information Interchange”
          EBCDIC
          “Extended Binary Coded Decimal Interchange Code”

          Comparing strings
        int strcmp( const char *s1, const char *s2 )
          Compares character by character
          Returns
        Zero if strings equal
        Negative value if first string less than second string
        Positive value if first string greater than second string
        int strncmp( const char *s1,
                                                                 const char *s2, size_t n )
          Compares up to specified number of characters
          Stops comparing if reaches null character in one of arguments



          Tokenizing
          Breaking strings into tokens, separated by delimiting characters
          Tokens usually logical units, such as words (separated by spaces)
          "This is my string"  has 4 word tokens (separated by spaces)
          char *strtok( char *s1, const char *s2 )
          Multiple calls required
          First call contains two arguments, string to be tokenized and string containing delimiting characters
          Finds next delimiting character and replaces with null character
          Subsequent calls continue tokenizing
          Call with first argument NULL





          Determining string lengths
          size_t strlen( const char *s )
          Returns number of characters in string
          Terminating null character not included in length


Pointers and Strings: Part Four

Thursday, 6 August 2015

Continuing with the previous post, today we will further study pointers and strings.

Pointer Expressions and Pointer Arithmetic:

Pointer arithmetic is of the following types:

–Increment/decrement pointer  (++ or --)
–Add/subtract an integer to/from a pointer( + or += , - or -=)
–Pointers may be subtracted from each other
but remember that pointer arithmetic is meaningless unless performed on pointer to array
consider an example where there is a 5 element int array on a machine using 4 byte integer space.
vPtr points to first element v[ 0 ], which is at location 3000
Vptr = v or vptr = &v[0]
vPtr += 2; sets vPtr to 3008

vPtr points to v[ 2 ]
 when subtracting pointers (must both point to the same array, if not then LOGIC ERROR)
–Returns number of elements between two addresses
  vPtr2 = &v[ 2 ];
vPtr = &v[ 0 ];
vPtr2 -
vPtr = 2
As far as pointer assignment is concerned:
–Pointer can be assigned to another pointer if both are of same type
–If not of the same type, cast operator must be used
–Exception: Void Pointer: pointer to void (type void *)

Void Pointer: Pointer to void (type void *):

int nValue = 5;
void *pVoid = &nValue;    //no need for casting
// can not dereference pVoid because it is a void pointer
int *pInt = static_cast<int*>(pVoid); // cast from void* to int*

cout << *pInt << endl; // can dereference pInt

Void Pointer:

the code given below shows an example of void pointers:

void f (void *,void*,int);
main()
{
int x=9,y=5;
char r='w',t='z';
                f(&r,&t,sizeof(r));
f(&x,&y,sizeof(x));
                cout<<x<<endl;
cout<<r<<endl;
}
void f(void* x, void* y, int sizeofptr)
{
int *nptr1, *nptr2;
char *nptr3, *nptr4;
if (sizeofptr == sizeof(int))
{ nptr1=(int* )x;
nptr2=(int* )y;
*nptr1=*nptr1**nptr2;}
else
{nptr3=(char* )x;
nptr4=(char* )y;
*nptr3=toupper(*nptr3);}
}

Relationship between Arrays and Pointers:

Arrays and pointers are closely related:
        Array name is like a constant pointer
        Pointers can do array subscripting operations:
                                    int b[5];
                                    int *bptr;
You can point ‘bptr’ to array ‘b’ using either;
                                    bptr = b;    //remember name of array is constant pointer to address of the first                                                           location of array  
                        Or
                                    bptr = &b[0];
Array elements can easily be accessed with pointers
        Element b[ n ] can be accessed by  *( bPtr + n )
          Called pointer/offset notation
          ‘n’ is the offset
          DO NOT forget the brackets, since * bPtr + n  will simply add n to *bPtr
        Accessing array addresses with pointers:
          &b[ 3 ] same as bPtr + 3
        Array name can be treated as pointer;
          b[ 3 ] same as *( b + 3 )
          This is possible since name of the array is a pointer itself.
        Pointers can be subscripted (pointer/subscript notation)
          bPtr[ 3 ] same as b[ 3 ]





Array of Pointers:

An array can contain pointers
–This is commonly used to store array of strings
char *suit[ 4 ] = {"Hearts", "Diamonds",
                
 "Clubs", "Spades" };
–Each element of suit points to char * (a string)
–Array does not store strings, only pointers to strings

suit array has fixed size, but strings can be of any size

Pointer & Strings: Part Three

 
Codexify © 2015 - Designed by Templateism.com