Changes between Version 1 and Version 2 of SDAP/cpp3

Timestamp:

06/18/08 12:55:45 (2 years ago)

Author:

sgtflame

Comment:

--

SDAP/cpp3

@@ -145 +145 @@
 ||yetAnotherValue||3||
 
-== Constant Pointers ==
-
-== Exercise ==
+== Exercise 1 ==
+
+Edit your !FirstProgram application and make it look something like this.
+
+{{{
+#!cpp
+int main(int _argc, char* _argv[])
+{
+    // Initialize three variables 
+    int value1(0);
+    int value2(0);
+    int value3(0);
+
+    // Declare a pointer
+    int* pointer1;
+
+    pointer1 = &value1;
+    pointer1 = &value2;
+    pointer1 = &value3;
+
+    value1 = 1;
+    value2 = 2;
+    value3 = 3;
+
+    // Get the value of the pointer by dereferencing it.
+    int returnValue(*pointer1);
+
+    // Return it
+    return returnValue;
+}
+}}}
+
+
+What will the value of '''returnValue''' be when the program returns?
+
+Compile the program, then step through it with the debugger.  Make sure you set a breakpoint on the line '''return returnValue'''.
+
+When you get to that point, hover over the variable name '''returnValue''' so it will tell you the value.  Did you get it right?
+
+Also, notice when you hover over a pointer, there's a little '''+''' or ''plus'' symbol next to it.  If you click on that symbol, the little window will expand and you will be able to see the value that the pointer is addressing.
+
+If you didn't get the answer right and you don't understand, please ask questions in the forums or on IRC.  irc://208.109.123.232:16667/indiezen
+
+== Constant Pointers and Pointers to Constants ==
+
+Ok, so we understand pointers now hopefully.
+
+Next, lets talk about '''constant pointers''' and '''pointers to constants'''
+
+In the previous C++ lesson we learned about '''constant variables''' using the keyword '''const'''.
+
+In this example, '''myValue''' is a constant integer that has (and always will have) a value of 10.
+
+{{{
+#!cpp
+    const int myValue(10);
+}}}
+
+
+Extending this example, lets add a pointer to the variable.
+
+{{{
+#!cpp
+    const int myValue(10);
+    const int* pPointerToMyValue(&myValue);
+}}}
+
+There, that was easy... '''pPointerToMyValue''' points to a constant integer and is initialized to the address of '''myValue'''.
+
+Now, note that pPointerToMyValue is not itself constant.  It only points to a constant value.
+
+In the following example, we declare and initialize another variable named '''anotherValue''' then we modify '''pPointerToMyValue''' so that it has the value of the address of '''anotherValue'''.
+
+{{{
+#!cpp
+    const int myValue(10);
+    const int* pPointerToMyValue(&myValue);
+
+    const int anotherValue(14);
+    pPointerToMyValue = &anotherValue;
+}}}
+
+This is legal because '''pPointerToMyValue''' is not constant.  ''The value that is pointed to by '''pPointerToMyValue''' is constant, but the pointer itself is not constant.''
+
+To make a pointer constant, you have to move the location of the keyword '''const'''.
+
+In this example we show '''myValue''' being initialized to 10.  Notice that '''myValue''' is not constant.
+
+In the following line, we declare '''pPointerToMyValue''' which is a constant pointer to an '''int'''.  This means that the pointer itself cannot change, however the value which it points to can change.
+
+In the third line of this example we show just that.  '''myValue''' is modified to have the value 14.  This is legal because '''myValue''' is not constant.
+
+{{{
+#!cpp
+    int myValue(10);
+    int* const pPointerToMyValue(&myValue);
+
+    myValue = 14;
+}}}
+
+If we were to change the program to look like this:
+
+{{{
+#!cpp
+    int myValue(10);
+    int* const pPointerToMyValue(&myValue);
+
+    myValue = 14;
+
+    int anotherValue(13);
+    pPointerToMyValue = &anotherValue;  /// WRONG!  pPointerToMyValue is const
+}}}
+
+... you would get a compile error.
+
+The following example would also cause a compile error.
+
+{{{
+#!cpp
+    const int myValue(10);
+    const int* pPointerToMyValue(&myValue);
+
+    const int anotherValue(14);
+    pPointerToMyValue = &anotherValue;  /// Legal, pPointerToMyValue is not const
+
+    myValue = 12;  /// WRONG!  myValue is const
+}}}
+
+Now, we can also combine these two '''const''' modifiers.
+
+In the following example, '''pPointerToMyValue''' is a constant pointer that points to a constant value.
+
+{{{
+#!cpp
+    const int myValue(10);
+    const int* const pPointerToMyValue(&myValue);
+
+    const int anotherValue(14);
+    pPointerToMyValue = &anotherValue;  /// WRONG!  pPointerToMyValue is const
+
+    myValue = 12;  /// WRONG!  myValue is const
+}}}
+
+== More Exercise ==
 
 If you would like more text explaining pointers, feel free to read HTPCPP Chapter 8.2.  If you're an experienced programmer, please feel free to read all of Chapter 8 if you're interested.
 
-Edit your !FirstProgram and 
+Edit your !FirstProgram and play around with '''int''' and '''int *''' data types and variables.  Be sure to use the debugger to see if the program behaves as you expected.
+
+Play around with the '''const''' and '''non-const''' variables and see if you can predict when you will get compiler errors due to assigning values to a constant variable.
+
+If you have any questions, please be sure to ask them in IRC or in the forums.