added progress

Author: trapperdot00

Chapter18/18.13.txt

@@ -0,0 +1,2 @@
+when needing variables that don't span multiple files and have a static lifetime
+or declaring file statics

Chapter18/18.14.txt

@@ -0,0 +1,5 @@
+mathLib::MatrixLib::matrix mathLib::MatrixLib::operator*(const matrix &, const matrix &);
+
+// as soon as the fully qualified name (mathLib::MatrixLib::operator*) is seen,
+// we are in the scope of that namespace,
+// so we can use matrix instead of mathLib::MatrixLib::matrix in the parameters

Chapter18/18.15.txt

@@ -0,0 +1,9 @@
+using declarations make only one member of a namespace visible,
+it can appear in global, local, namespace or class scope (only to refer to base class members)
+declares a local alias for the selected namespace member
+immediately throws an error if there is a name clash
+
+using directives make all members of a namespace visible
+it can appear in global, local or namespace scope
+lifts the namespace members in the nearest scope that contains both the namespace and the using directive
+if there is a name clash, throws error when trying to use the clashing name, not immediately

Chapter18/18.16.txt

@@ -0,0 +1,93 @@
+			-- using declarations --
+a)
+namespace Exercise {
+	int ivar = 0;
+	double dvar = 0;
+	const int limit = 1000;
+}
+
+int ivar = 0;
+using Exercise::ivar;
+using Exercise::dvar;
+using Exercise::limit;
+void manip() {
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;
+	++::ivar;
+}
+// using declaration of Exercise::ivar is an error, can't declare an alias
+// with the same name as ivar, as it is in the current scope
+// dvar and limit is added to the global scope as a local alias from the Exercise namespace
+// manip declares a variable named dvar, that hides the outer scope's dvar
+// iobj is initialized to Exercise::limit + 1
+// if we removed the erroneous using declaration, both incrementing of ivar would increment
+// the global one
+
+b)
+namespace Exercise {
+	int ivar = 0;
+	double dvar = 0;
+	const int limit = 1000;
+}
+
+int ivar = 0;
+void manip() {
+	using Exercise::ivar;
+	using Exercise::dvar;
+	using Exercise::limit;
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;
+	++::ivar;
+}
+// ivar, dvar and limit from the namespace Exercise is put into manip as a local alias
+// the declaration of ivar hides the global ivar inside the manip function
+// the declaration of dvar after the using declaration of Exercise::dvar would be an error
+// ++ivar increments Exercise::ivar
+// ++::ivar increments ivar in the global scope
+
+			-- using directive --
+a)
+namespace Exercise {
+	int ivar = 0;
+	double dvar = 0;
+	const int limit = 1000;
+}
+
+int ivar = 0;
+using namespace Exercise;
+void manip() {
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;
+	++::ivar;
+}
+// using directive lifts Exercise's members in the nearest scope that contains Exercise and the directive:
+// into the global scope
+// clash between ::ivar and Exercise::ivar, detected only if ivar is used
+// declaration of dvar inside manip hides the dvar inside the global scope
+// ++ivar is ambiguous: global ivar, or Exercise::ivar?
+// ++::ivar increments the global ivar (::ivar is a qualified name)
+
+b)
+namespace Exercise {
+	int ivar = 0;
+	double dvar = 0;
+	const int limit = 1000;
+}
+
+int ivar = 0;
+void manip() {
+	using namespace Exercise;
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;
+	++::ivar;
+}
+// using directive lifts Exercise's members in the nearest scope that contains Exercise and the directive:
+// into the global scope
+// clash between ::ivar and Exercise::ivar, detected only if ivar is used
+// declaration of dvar inside manip hides the dvar inside the global scope
+// ++ivar is ambiguous: global ivar or Exercise::ivar?
+// ++::ivar increments the global ivar (::ivar is a qualified name)

Chapter18/18.17/Exercise.cpp

@@ -0,0 +1,7 @@
+#include "Exercise.h"
+
+namespace Exercise {
+	int ivar = 0;
+	double dvar = 0;
+	extern const int limit = 1000;
+}

Chapter18/18.17/Exercise.h

@@ -0,0 +1,5 @@
+namespace Exercise {
+	extern int ivar;
+	extern double dvar;
+	extern const int limit;
+}

Chapter18/18.17/using_declaration_position_1.cpp

@@ -0,0 +1,12 @@
+#include "Exercise.h"
+
+int ivar = 0;
+using Exercise::ivar;	// error: target of using declaration conflicts with declaration already in scope
+using Exercise::dvar;
+using Exercise::limit;
+void manip() {
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;
+	++::ivar;
+}

Chapter18/18.17/using_declaration_position_2.cpp

@@ -0,0 +1,12 @@
+#include "Exercise.h"
+
+int ivar = 0;
+void manip() {
+	using Exercise::ivar;
+	using Exercise::dvar;
+	using Exercise::limit;
+	double dvar = 3.1416;	// error: declaration conflicts with target of using declaration already in scope
+	int iobj = limit + 1;
+	++ivar;
+	++::ivar;
+}

Chapter18/18.17/using_directive_position_1.cpp

@@ -0,0 +1,10 @@
+#include "Exercise.h"
+
+int ivar = 0;
+using namespace Exercise;
+void manip() {
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;					// error: reference to ivar is ambiguous
+	++::ivar;
+}

Chapter18/18.17/using_directive_position_2.cpp

@@ -0,0 +1,10 @@
+#include "Exercise.h"
+
+int ivar = 0;
+void manip() {
+	using namespace Exercise;
+	double dvar = 3.1416;
+	int iobj = limit + 1;
+	++ivar;					// error: reference to ivar is ambiguous
+	++::ivar;
+}

Chapter18/README.md

@@ -61,3 +61,44 @@ Write a program that uses the Sales_data addition operator on objects that have
 Why is it important that the what function doesn’t throw?
 ## [Exercise 18.12](18.12)
 Organize the programs you have written to answer the questions in each chapter into their own namespaces. That is, namespace chapter15 would contain code for the Query programs and chapter10 would contain the TextQuery code. Using this structure, compile the Query code examples.
+## [Exercise 18.13](18.13.txt)
+When might you use an unnamed namespace?
+## [Exercise 18.14](18.14.txt)
+Suppose we have the following declaration of the operator* that is
+a member of the nested namespace mathLib::MatrixLib:
+```
+    namespace mathLib {
+        namespace MatrixLib {
+            class matrix { /* ... */ };
+            matrix operator*
+                    (const matrix &, const matrix &);
+            // ...
+        }
+    }
+```
+How would you declare this operator in global scope?
+## [Exercise 18.15](18.15.txt)
+Explain the differences between using declarations and directives.
+## [Exercise 18.16](18.16.txt)
+Explain the following code assuming using declarations for all the
+members of namespace Exercise are located at the location labeled position 1. What
+if they appear at position 2 instead? Now answer the same question but replace the
+using declarations with a using directive for namespace Exercise.
+```
+    namespace Exercise {
+        int ivar = 0;
+        double dvar = 0;
+        const int limit = 1000;
+    }
+    int ivar = 0;
+    // position 1
+    void manip() {
+        // position 2
+        double dvar = 3.1416;
+        int iobj = limit + 1;
+        ++ivar;
+        ++::ivar;
+    }
+```
+## [Exercise 18.17](18.17)
+Write code to test your answers to the previous question.