Namespaces

• The first chapter of the book is really worth a read.
• Namespaces (P 9)
  • 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 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.
• Chapter 1 has other good stuff in it.
  • Give it a read.