Friends

• A class can declare a friend function or class
• When this happens, the friended class has access to the original class' private members.
• Look at the code friends.cpp

Namespaces

• 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 sad, no Daniel's in the class this semester
    • 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 if 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 669 and 670 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);
        }

• 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.
• Look at distance.cpp.