Advanced C+ to Classes

• The first chapter of the book is really worth a read.
  • I was going to skip it, but there are several syllabus and class related topics we need.
• Namespaces (P 8)
  • We have discussed namespaces briefly in 230
    • I think I used the example of "Daniel" because my ego is that big.
      • In the student namespace "Daniel" is Mr. Rosales.
      • In the instructor namespace "Daniel" is me.
      • By knowing what namespace we are in allows us to determine the person to which we are referring.
  • But what about code and why?
  • In a larger project does it make sense we might have multiple functions with the same signature ( name AND parameters).
    • Ie, we do not want function overloading
    • We just want the same function doing different things.
  • Consider this
    • In the plane we normally measure distance using the euclidean distance.
      • $d(x_1,y_1,x_2,y_2) = \sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}$
    • But there are several different ways to do this.
      • Using the taxi cab or Manhattan distance,
        • $d(x_1,y_1,x_2,y_2) = |x_1-x_2| + |y_1-y_2|$
        • This represents how you drive in a city (ie city blocks);
      • The Hausdorff distance in 2d
        • $d(x_1,y_1,x_2,y_2) = max(|x_1-x_2| , |y_1-y_2|)$
        • This measures the distance between two sets.
        • It does have computer applications.
  • So I were working on a project I might want to use all three distances available.
  • I can use namespaces to control this.
    • Why not just name them different things?
    • Why not just pass a parameter to indicate the one I want?
  • I am going to use a few tricks to keep my code clean
    • A pair is an easy way to build a "two thing" variable.
      • This is a standard container.
      • Discuss on 576 and 577 of the book.
      • A reference is here
      • This will be convenient for my points in a distance demo.
        • The code is contained in <utility
        • It takes two types
        • Access is through .first and .second

        • #include <utility>
          using namespace std;
          ..
          typedef pair<double, double> point;
          
          ...
          pair <double, double> x1;
          x1.first = 0;
          x2.second = 0;
          point x2{10,5};
          
          double Distance(pair<double,double> a, point b) {
              double dx, dy;
          
              dx = a.first- b.first;
              dy = a.second - b.second;
          
              return sqrt(dx*dx + dy*dy);
          }
                                 

    • I also want to overload the stream insertion operator.
      • This is on page 485
      • We discussed operator overloading before
      • and << wrt streams is an operator.
      • Overloading the stream insertion operator allows you to do something like

      • point x1{0,0}, x2{10,5};
        
        cout << "Computing the distance from " << x1 << " to " << x2 << endl; 

      • Parameters:
        • an output stream passed by reference.
        • An object you wish to output. This should be a constant reference
      • Return value, a reference to the stream.

        • cout << a;
           // is equivalent to , but we can't call it this way.
          <<(cout,a);
          
           // is equivalent to , but we can't call it this way.
          cout << a << b;
          <<(<<(cout,a),b); 

      • So the actual overload is quite easy

        ostream & operator << (ostream & s, const point &  p) {
            s << "(" << p.first <<", " << p.second << ")";
            return s;
        } 

  • To access an element of a namespace you use the scope resolution operator or ::

    • //namespaceName::object_in_namespace
      string::npos 

  • By default, everything you declare that is not in a namespace is in the global namespace.
    • So ::object refers to an object in the global namespace.
  • We can add other namespaces

    • /* namespace name {
           // declare objects in the namespace.
         }
      */
      
      namespace Euclid  {
      
          const string D_NAME = "Euclidian";
          int avar = 10;
      
          double Distance(point a, point b) {
               double dx, dy;
      
               dx = a.first- b.first;
               dy = a.second - b.second;
      
               return sqrt(dx*dx + dy*dy);
           }
      }
                  

    • You can also declare it in multiple locations

      • namespace Manhattan {
            const string D_NAME = "MANHATTAN";
            int avar = 20;
            double Distance(point a, point b);
        }
        ...
        double Manhattan::Distance(point a, point b) {
            double dx, dy;
        
            dx = abs(a.first- b.first);
            dy = abs(a.second - b.second);
        
            return (dx + dy);
        }
                       

  • You can nickname a namespace

    namespace HD=Hausdorf;
            

  • you can nest namespaces.
  • using namespace name makes it active but beware
    • This sort of defeates the reason to have namespaces.
  • Don't put using namespace ... in header files.
    • They are directly imported into the source code that uses them.
    • And thus that namespace is imported as well.
  • Namespaces can be declared across multiple files.
• Chapter 1 has other good stuff in it.
  • Give it a read.