CtoC++ - Revision history

GethinWilliams: /* Templates and the Standard Template Library */

2014-02-14T12:18:47Z

Templates and the Standard Template Library

GethinWilliams: /* Templates and the Standard Template Library */

2014-02-14T12:14:43Z

Templates and the Standard Template Library

GethinWilliams: /* Templates and the Standard Template Library */

2014-02-14T12:14:16Z

Templates and the Standard Template Library

GethinWilliams at 17:05, 28 February 2011

2011-02-28T17:05:22Z

GethinWilliams: /* Inheritance */

2011-02-23T15:02:48Z

Inheritance

GethinWilliams: /* Inheritance */

2011-02-23T14:53:50Z

Inheritance

GethinWilliams: /* Templates and the Standard Template Library */

2011-02-23T14:52:34Z

Templates and the Standard Template Library

GethinWilliams: /* More on Methods */

2011-02-23T14:45:43Z

GethinWilliams: /* More on Methods */

2011-02-23T14:31:48Z

GethinWilliams: /* Cutting to the Chase: Classes and Encapsulation */

2011-02-23T13:23:24Z

Cutting to the Chase: Classes and Encapsulation

@@ Line 451: / Line 451: @@
    stack<char> charStack;  // a stack of characters
    stack<int>  intStack;   // a stack of integers
 ...
 </source>

@@ Line 423: / Line 423: @@
    charLifo.push('S');
 ...
-<\source>
+</source>
 you can run the example program by typing:

@@ Line 402: / Line 402: @@
 Note the use of the wildcard name '''TYPE''' in the angle brackets (this name could be anything, but TYPE in capitals stands out nicely).  The interface to the class contains methods for construction and destruction, as well as the basic modes of operation--'''push'''ing and '''pop'''ing items on to and off the stack.  We have a method to report what's on the top of the stack and a couple more to report whether the stack is 'full' or 'empty'.
-Feel free to browse the details of the implementation, but we'll skip over them here.  They are relatively rudimentary and no doubt could tolerate a good deal of improvement.  The short piece of glue code is contained in '''main.cc''' and you can run the example program by typing:
+Feel free to browse the details of the implementation, but we'll skip over them here.  They are relatively rudimentary and no doubt could tolerate a good deal of improvement.  The short piece of glue code is contained in '''main.cc''':
 <pre>

← Older revision		Revision as of 17:05, 28 February 2011
Line 523:		Line 523:

	* There is a good deal more to discuss on the topic of inheritance, but I will leave researching those details as an exercise to the reader for the moment.		* There is a good deal more to discuss on the topic of inheritance, but I will leave researching those details as an exercise to the reader for the moment.
		+
		+	=A Good Read?=
		+
		+	* [[A_Good_Read\|References]] for further reading.

@@ Line 516: / Line 516: @@
 ./inheritance.exe
 </pre>
 '''Exercises'''
 * There is a good deal more to discuss on the topic of inheritance, but I will leave researching those details as an exercise to the reader for the moment.

@@ Line 451: / Line 451: @@
 =Inheritance=
-The last topic that we will look at is '''inheritance'''.  This is a mechanism through which you can declare a new class--called the '''derived class'''--to be a specialisation of another class--called the '''base class'''.  In line with the spirit of the '''pragmatic programming''' tutorials, we will not linger on this topic as we believe that while it is certainly neat, it is most likely of limited use in most scientific projects.
+The last topic that we will look at is '''inheritance'''.  This is a mechanism through which you can declare a new class--called the '''derived class'''--to be a specialisation of another class--called the '''base class'''.  In line with the spirit of the '''pragmatic programming''' tutorials, we will not linger on this topic as we believe that while it is certainly neat, it may be of limited use for our scientific projects.
 In this example, we will consider the simplest, but quite likely the most often used, form on inheritance--'''public''' inheritance from a single parent base class.

@@ Line 400: / Line 400: @@
 </source>
-Note the use of the wildcard name '''TYPE''' in the angle brackets (this name could be anything, but TYPE in capitals stands out nicely).  The interface to the class contains methods for construction and destruction, as well as the basic modes of operation--'''push'''ing and '''pop'''ing items on and off the stack.  We have a method to report what's on the top of the stack and a couple more to report whether the stack is full or empty.
+Note the use of the wildcard name '''TYPE''' in the angle brackets (this name could be anything, but TYPE in capitals stands out nicely).  The interface to the class contains methods for construction and destruction, as well as the basic modes of operation--'''push'''ing and '''pop'''ing items on to and off the stack.  We have a method to report what's on the top of the stack and a couple more to report whether the stack is 'full' or 'empty'.
 Feel free to browse the details of the implementation, but we'll skip over them here.  They are relatively rudimentary and no doubt could tolerate a good deal of improvement.  The short piece of glue code is contained in '''main.cc''' and you can run the example program by typing:
@@ Line 408: / Line 408: @@
 </pre>
-One of the reasons, why we haven't laboured too hard over our stack implementation is because C++ provides us with something called the '''Standard Template Library''', or STL, for short.  This contains tried and tested implementations of of many data structures and algorithms that we would like.  All there provided for us!
+One of the reasons, why we haven't laboured too hard over our stack implementation is because C++ provides us with something called the '''Standard Template Library''', or '''STL''', for short.  This contains tried and tested implementations of of many data structures and algorithms that we would like.  All there, provided to us for free!
 An example of using a stack from the STL is in:
@@ Line 437: / Line 437: @@
 </pre>
-For good measure, you will also see an example of a list sourced from the STL, and an associated '''iterator''' for cycling through the members of said list.
+For good measure, you will also see an example of a '''list''' sourced from the STL, and an associated '''iterator''' for cycling through the members of said list.  Iterators allow us to cycle over members of a data structure without having to know the details of how that particular data structure is implemented.
 To learn more about the STL, you can take a look at, e.g. [http://www.sgi.com/tech/stl SGI's page] or [http://en.wikipedia.org/wiki/Standard_Template_Library that on Wikipedia].  [http://oreilly.com/pub/topic/cprog O'Reilly], of course, have a few good books on the topic too.

@@ Line 165: / Line 165: @@
 In this directory, you'll see that we've split our program over the files;
-# '''methods.h''', containing the declarations for our enhanced satellite class,
+# '''methods.h''', containing the declarations (names and types of arguments) for our enhanced satellite class,
 # '''methods.cc''', containing the 'meat' of the methods and,
-# '''main.cc''', containing the main function inside which we run our class through it's paces.
+# '''main.cc''', containing the main function inside which we put our class through it's paces.
 Looking inside the header file, you'll see our scientific namespace again, as well as the class declaration:
@@ Line 213: / Line 213: @@
 </source>
-This time around we have some extra class members:
+This time around we have some extra members:
 * We have a character pointer called '''name''', along with an integer to store the length of the character array, once some memory has been allocated.
-* We have a number of '''constructors''' methods, which we immediately see are special since their shared name matches the name of the class.
+* We have a number of '''constructor''' methods, which we immediately see are special since their (shared) name matches the name of the class.
-* We have a '''destructor''', where it's name has a leading twiddle ('''~''') and also matches the class name.
+* We have a '''destructor''', where it's name also matches the class name, but with a leading twiddle ('''~''').
 * We have a private method called '''copy''',
 * a '''display''' method and also
@@ Line 230: / Line 230: @@
 </source>
-Here we've declared two instances of the satellite class, and called them '''moon1''' and '''moon2'''.  We created moon1 using the '''default constructor''' (no arguments follow the variable name).  The internals of which we can find inside '''methods.cc''':
+Here we've declared two instances of the satellite class and--imaginatively enough--called them '''moon1''' and '''moon2'''.  We created moon1 using the '''default constructor''' (no arguments follow the variable name).  The internals of which we can find inside '''methods.cc''':
 <source lang="cpp">
@@ Line 244: / Line 244: @@
 </source>
-As it's name suggests, this method sets up a default object (zero values, null strings etc.) in lieu of any specific information.
+As it's name suggests, this method sets up an object with default values (zero values, null strings etc.) in lieu of any specific information.
-moon2 was created using a constructor which takes arguments:
+'''moon2''' was created using a constructor which takes arguments:
 <source lang="cpp">
@@ Line 258: / Line 258: @@
 This method accepts the name of the satellite instance, together with values for the period and the semi-major axis.  Given these, it merely calls the '''set()''' method, which is sensible since this method has all the functionality that we desire, and it's a bad idea to duplicate the code.
-We can see that these two methods have exactly the same save and differ only in their associated argument lists.  This is an example of what's called '''overloading''', which can be highly desirable when designing clear and simple class interfaces.  We can overload both methods and operators.
+We can see that these two methods have exactly the same save and differ only in their associated argument lists.  This is an example of what's called '''overloading''', which can be highly desirable when designing clear and simple class interfaces.  We can overload methods and operators.
-You will see that we also have what we've labelled as a '''copy constructor''', which takes another instance of the satellite class as it's argument and creates another in it's image.
+You will see that we also have what we've labelled as a '''copy constructor''', which takes another instance of the satellite class as it's argument, and creates a new object in it's image.
 <source lang="cpp">
@@ Line 267: / Line 267: @@
 </source>
-This method makes use of a '''member initializer''' and calls the private copy method (not available from outside the class, but callable from other members).  Member initializers are carried out before the method itself is called and are always done in order.  In this case, we've set '''name''' equal to '''NULL''' so as to avoid some unnecessary dynamic memory allocation manoeuvres in the copy method.
+This method makes use of a '''member initializer''' and calls the private copy method (not available from outside the class, but callable from other members).  Member initializers are carried out before the method itself is called and are always done in order.  In this case, we've set '''name''' equal to '''NULL''' so as to avoid dynamic memory allocation manoeuvres in the copy method.
 C++ will provide what's known as '''shallow''' copy constructor, assignment and destructor methods implicitly, which are fine for classes which do not make use of dynamic memory allocation.  However, for more complex classes, we must write our own '''deep''' copying methods.  For example, our copy method:
@@ Line 286: / Line 286: @@
 </source>
-The copy needs to be deep, as if we were not careful, we would end up with two classes containing pointers to the same block of memory (holding the 'name' character array) and that would not be at all what we wanted!  Instead we allocate some new memory and call a string copying method from the standard C library.  Copying the values of the numerical variables is easy.  We've made use of the new C++ memory allocation function '''new''', which we can all agree are far simpler than 'malloc()'.  Correspondingly '''delete''' replaces 'free()'.
+The copy needs to be deep, as if we were not careful, we would end up with two classes containing pointers to the same block of memory (holding the 'name' character string) and that would not be at all what we wanted!  Instead we allocate some new memory and call a string copying method from the standard C library.  Copying the values of the numerical variables is easy.  We've made use of the new C++ memory allocation function '''new''', which we can all agree is far simpler than 'malloc()'.  Correspondingly '''delete''' replaces 'free()'.
 None of the other methods warrant any comment, except for the assignment operator:
@@ Line 323: / Line 323: @@
 '''Exercises'''
-* Experiment with the copy constructor.  For example, it is legal syntax to add the declaration '''satellite moon3(moon2);''' towards the end of the main function.
+* Experiment with the copy constructor.  For example, is it legal syntax to add the declaration '''satellite moon3(moon2);''' towards the end of the main function?
 * Method arguments can have defaults attached, e.g. '''satellite(const char *nm, const double prd=0.0, const double sma=0.0)'''.  Experiment with the constructor with arguments.  How much more flexibility can you introduce to the interface?  '''Note''' that your default values should only be added to the declaration of the class (i.e. inserted in the header file), and your default arguments must be all the rightmost arguments in the list.
 * Can you define other methods/operators for this class?  How about 'less than' (<) or 'greater than' (>) operators.  If two satellites were to collide and coalesce, what could a plus (+) operator do?

@@ Line 157: / Line 157: @@
 =More on Methods=
-OK, so far so good.  We've bundled up some methods and variables into a class.  This is all to the good.  However, we haven't delved too deeply into all the features that C++ provides with regards to methods.  Let's rectify that right now.  We'll make a start by typing:
+OK.  We've bundled up some methods and variables into a class.  This is all to the good.  However, we haven't delved too deeply into all the features that C++ provides with regards to methods.  Let's rectify that right now.  We'll make a start by typing:
 <pre>

@@ Line 153: / Line 153: @@
 * Add a whole new class to the program.  This is just for practice, so it could be a very simple one.  How about a class to represent a 2-d vector (i.e. on the x-y plane), which has a method to report the magnitude of that vector?
-[[Image:2D-vec-schematic.jpg|300px|thumbnail|centre|Coordinates and magnitude of a 2D vector.]]
+[[Image:2D-vec-schematic.jpg|150px|thumbnail|centre|Coordinates and magnitude of a 2D vector.]]
 =More on Methods=