Strings

In C/C++ a string is an array of char but is assumed to be null terminated.

All the functions that work with strings assume that they are null-terminated. So just like arrays, you have to be careful and do your own error checking to make sure that you do not reference outside of the allocated space for the string.

String Values

String values are easiest to declare within double quotes:

	char clown[] = "bozo";       //Compiler figures out size

The size is the number of characters plus 1 for the null terminator. We can alternately declare the above string as follows:

    char clown[5] = {'b', 'o', 'z', 'o', '\0'};

    or

    char clown[] = {'b', 'o', 'z', 'o', '\0'};

A Few Demos to Look at

strlen.cpp

strlen2.cpp

Test: s[i++]
- Increment i after use.
- Test is whether s[old i] is terminator.
Return i-1 because last increment was one too many.

stringDemo.cpp

cin to string.
cout from string - We have been doing this all along.
strlen from string.h
strcat
strcpy
strcmp(s1, s2)
- < 0 if s1 < s2
- = 0 if s1 = s2 - This is weird, but 0 really means equal here.
- > 0 if s1 > s2
strncpy
toupper
All of the above & more can be found in Appendix 4 of the book.
Also, cin.getline gets input into a variable, and will do a whole line up to the carriage return.

Pointers

You can think of computer memory as a huge array of bytes.

We call each "index" an address.

Definition of a pointer

A pointeris a data type whose value is an address. That is to say, it is not an int, double, or anything else but an address.
We say that a pointer points to or references a memory location.
To get the value in the location a pointer references, we must dereference the pointer.
Examples of pointers in everyday life:
- Darv & me
- Index in a book.

If pointer values are addresses, how do we come up with address values in the first place? What is the analog of a constant for an address?

NULL

NULL is a special predefined pointer value that points to nothing. We won't use it much for now, but it will be quite useful later so keep it in the back of your mind. Note also that NULL is actually just a 0, so we can test against 0 for NULL.

& operator

We can express the address of any variable by making use of the &:


    int i;
    double x;

    ... &i ...
    ... &x ...

In C/C++, when you declare a pointer, you must also declare what type it points to.


    int bozo;    //an int
    int *ip;     //ptr to an int

    ip = &bozo;

    *ip = 5;

So, once ip = &bozo executes, *ip = 5 and bozo = 5 are the same.

How to interpret

* means to dereference.
int *ip means "*ip is an int".
Therefore, dereferencing ip gives an int.
Therefore, ip is a pointer to an int.

Syntax

We can write the declaration as:
- int *ip;
- int* ip;
PLEASE, use the first way.
It is a matter of consistency with the interpretation just given.

Also, what does this look like??

    int* ip, jp;  // makes ip a pointer to an int, jp an int

So we would need:
```
    int *ip, *jp;
```
to make them both pointers to ints.

Make sure that you see the demo pointer1.cpp and run it!

Statement ip = jp causes aliasing.
If you uncomment the line
```
    xp = ip;
```
you get an error, because ip must point to an int and xp must point to a double, and never the twain shall meet.

To Index Previous Next