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.
The Preprocessor
- Read the secion on preprocessor directives on page 5-6
- Note that #include may start to go away
  - In c++ 20 they introduced modules.
  - These will replace header/implementation files.
  - Stroustrup says
    - #include was introduced in 1972
    - Putting #include files in dfferent order can cause problems (but not as many as in the past)
    - Modules will be much easier to use
    - Modules will be much more efficient.
    - Modules and #include will need to live side-by side for quite a while
- Guards
  - Remember
```
#ifndef SOME_STRING
#define SOME_STRING

code
#endif 
```
  - This can be replaced with
  - ```
  #pragma once 
```
- #pragma once is not standard
- But it is supported by many compilers
- Sources say it is
  - More efficient
  - Less error prone than guards.
- See This code for an example.
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 world namespace "Daniel" is Mr. Boone
    - Altho, you might think otherwise
    - In the local namespace "Daniel" is me.
    - 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 and qualifiers).
  - 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 in a large project all three distances might be implemented and 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.
    - ```
    stream & operator <<(stream & s, type t);
                    
```
- 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.
- You can selectively use an item from a namespace
  - ```
  using std::cout; 
```
- 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.