Object Oriented Programming with C++
3. C++ namespaces, operators, and expressions
By: Prof. Pandav Patel
Third Semester, July 2020
Computer Engineering Department
Dharmsinh Desai University
C++ namespaces
New concept introduced in C++
Declarative region that provides a scope to the identifiers
(the names of types, functions, variables, etc) inside it
Used to organize code into logical groups and to prevent
name collisions (e.g. when code includes multiple libraries)
Scope resolution operator (::) can be used to access
variables in other scopes
using keyword can be used to introduce specific members
of a namespace in to the current scope or all members of
the namespace in to the scope of common parent
Namespaces can be nested
C++ namespaces
#include<iostream>
using namespace std;
namespace nspace
{
int x = 11;
void fun()
{
cout << "Hello!" << endl;
}
}
int main()
{
//fun(); // Invalid
nspace::fun();
//cout << x << endl; // Invalid
cout << nspace::x << endl;
return 0;
}
C++ namespaces
#include<iostream>
using namespace std;
namespace nspace
{
int x = 11;
void fun()
{
cout << "Hello!" << endl;
}
}
using nspace::fun; //using declaration
int main()
{
fun();
nspace::fun();
//cout << x << endl; // Invalid
cout << nspace::x << endl;
return 0;
}
C++ namespaces
#include<iostream>
using namespace std;
namespace nspace
{
int x = 11;
void fun()
{
cout << "Hello!" << endl;
}
}
using namespace nspace; //using directive
int main()
{
fun();
nspace::fun();
cout << x << endl;
cout << nspace::x << endl;
return 0;
}
C++ namespaces
#include<iostream>
using namespace std;
int x = 10;
namespace nspace
{
int x = 20;
void fun()
{
int x = 30;
cout << x << " " << nspace::x << " " << ::x << endl;
}
}
int main()
{
nspace::fun();
return 0;
}
C++ namespaces
A namespace can be split into multiple blocks and those blocks can be in
the same file or separate files.
One file can contain blocks of multiple namespaces
1.cpp 2.cpp
namespace namespace xyz
abc {
{ ...
... }
}
namespace
namespace xyz abc
{ {
... ...
} }
namespace namespace xyz
abc {
{ ...
C++ namespaces
#include<iostream> #include<iostream>
int x = 1;
int x = 1;
namespace nspace
namespace nspace {
{ int x = 2;
int x = 2; int y = 3;
int y = 3; }
} int main()
int main() {
int y = 4;
{
using namespace nspace;
int y = 4; //error: reference to ‘x’ is ambiguous
//error: ‘y’ is already declared in this scope //std::cout << x;
//using nspace::y; std::cout << " " << y;
using nspace::x; int fun();
std::cout << x << " " << y; fun();
int fun(); return 0;
}
fun();
void fun()
return 0; {
} std::cout << x;
int fun() }
{
Here all members of the namespace nspace have been introduced in the
std::cout << x; global scope
}
This introduction of nspace members in the global space is only applicable
Here member x of namespace nspace has been within main function as using directive is within main.
Produces error only if we try to access x
introduced within main function scope
Avoid using namespace std; as it pollutes the global scope
C++ Operators
All C language operators are valid in C++
C++ introduces some new operators
Insertion operator (<<) and extraction operator (>>)
Scope resolution operator (::)
Member dereferencing operators (::*, ->*, .*)
Memory management operators (new and delete)
Type cast operator
Manipulators (endl, setw etc)
C++ Operators
Memory management operators (new and delete)
Like C language, malloc, calloc, realloc and free will still work
New operators new and delete are added
malloc, calloc, realloc and free are just functions
new and delete are operators (and keywords). A.k.a Free store operators
Use std::vector if you ever need to realloc (realloc would still work for
memory allocaed using malloc and calloc, but it is discouraged in favor of
std::vector)
Like malloc and calloc, lifetime of memory allocated using new is
controlled by programmer
No inbuilt feature for garbage collection like other OOP languages
You can use malloc and new in the same program. But you cannot allocate
an object with malloc and free it using delete. Nor can you allocate with
new and delete with free or use realloc on an array allocated by new.
C++ Operators
Memory management operators (new and delete)
pointer-variable = new data-type(value);
data-type could be fundamental or user-defined
pointer-variable is pointer to data-type
e.g. int *p1; p1 = new int;
Constructor is called after memory is allocated
Safe to assume that it is initialized with garbage by default
e.g. int *p2 = new int; *p2 = 10;
e.g. float *p3 = new float(25.5);
delete pointer-variable;
pointer-variable must be pointer returned by new (which is not
already deleted)
e.g. delete p1; //Frees memory, does not delete pointer itself
C++ Operators
Memory management operators (new and delete)
Memory can be allocated using new for array
pointer-variable = new data-type[10];
e.g. int *p4 = new int[10];
e.g. int *p5 = new int[10](); //Initialize all elements with 0 c++03
e.g. int *p6 = new int[10]{1, 2, 3}; //c++11
In case of multi-dimentional arrays, all sizes must be supplied
e.g. int (*p7)[5] = new int[4][5];
e.g. int (*p8)[5] = new int[m][5];
First dimention can be variable, others must be constant.
Why??
delete [size] pointer-variable;
e.g. delete [] p4;
e.g. delete [] p7;
C++ Operators
Memory management operators (new and delete)
If call to new fails it will throw exception and programm will terminate
unless you handle that exception by catching it (will learn later)
It would throw bad_alloc exception
If call to delete fails then also program will terminate like free
It would not throw exception
It is good practice to free the memory when it is no longer required
If you do not free the memory explicitly, it will be freed when program
execution ends
Advantages of new over malloc
Automatically computes size
Returns correct pointer type (No explicit type cast needed)
Possible to initialize value while allocating memory
new and delete operators could be overloaded
C++ Operators
Type cast operator
(type-name) expression; //C style, still valid in C++
e.g. int i = (int)f; int i = (int)5.3;
type-name(expression); //C++ style
e.g. int i = int(f); int i = int(5.3);
Can only be used if type-name is following the rules of
identifier
p = int * (q); // Invalid
typedef int * int_pt; p = int_pt(q); // Valid
C++ Operators - Manipulators
Manipulators
If a pointer to function (which returns ostream reference and takes
ostream reference as first argument) is given as the second argument
to << , the function pointed to is called. For example, cout << pf
means pf(cout) . Such a function is called a manipulator.
>> needs - function which returns istream reference and takes
istream reference as first argument – to work as manipulator for input
streams.
manipulator is a function that can be invoked by << or >>
Manipulators are used to format data
Can be used to format input and output streams. But frequently
used to format output streams.
Iomanip contains declaration for many such manipulators
These manipulators internally call member functions of ios class
C++ Operators - Manipulators
Manipulators (Only few important ones) Explore more here
Manipulator Meaning
endl Insert newline and flush stream
setw(int w) Set field width to w. It only applies to next value to
be inserted, then it is reset to default (0)
setfill(int c) Set the fill character to c. Default is space.
left Append fill characters at the end
right Insert fill characters at the beginning
setprecision(int d) Set the floating point precision to d.
fixed Floating-point values are written using fixed-point
notation: the value is represented with exactly as
many digits in the decimal part as specified by the
precision field
C++ Operators – Manipulators
#include<iostream>
#include<iomanip>
int main()
{
std::cout << std::setw(10) << "Hello" << std::endl; Hello
std::cout << "Hello" << std::endl; Hello
std::cout << std::setw(2) << "Hello" << std::endl << std::endl; Hello
std::cout << std::left << std::setfill('*'); Hello****
std::cout << std::setw(9) << "Hello" << std::endl;
Hello**
std::cout << std::setw(7) << "Hello" << std::endl << std::endl;
std::cout << std::setprecision(2) << 111.11111 << std::endl; 1.1e+02
std::cout << 1.11111 << std::endl; 1.1
std::cout << std::setprecision(10) << 111.11111 << std::endl; 111.11111
std::cout << 1.11111 << std::endl << std::endl; 1.11111
std::cout << std::fixed; 111.11
std::cout << std::setprecision(2) << 111.11111 << std::endl;
1.11
std::cout << 1.11111 << std::endl;
std::cout << std::setprecision(10) << 111.11111 << std::endl; 111.1111100000
std::cout << 1.11111 << std::endl << std::endl; 1.1111100000
return 0;
}
C++ Operators - Manipulators
#include<iostream>
std::ostream & have_fun(std::ostream &output)
{
output << std::endl << "Have Fun";
return output;
}
int main()
{
std::cout << "Hello there,"; Hello there,
std::cout << have_fun << ", you guys!!" << std::endl; Have Fun, you guys!!
std::endl(have_fun(std::cout) << ", you guys!!"); Have Fun, you guys!!
return 0;
}
C++ Expressions and implicit
conversions
Avoid mix of signed and unsigned numbers in an expression
Explicitly type-casting is good practice to avoid confusion
During evaluation of an expression
All char and short - variables and constants - are converted
to int first
Then smaller type is converted to wider type before applying
operator
int, long, float, double, long double
e.g. ‘A’ + 3 + 6.5 // result would be double as 6.5 is double
C++ Expressions and implicit
conversions
Operator precedence and
associativity does not guarantee
order of evaluation
#include<iostream>
int i = 2;
int fun()
{
i++;
return i;
}
int main()
{
int n = fun() + fun() * fun();
std::cout << n << std::endl;
return 0;
}
// Prints 23 for me on g++, could be
something else in your case
C++ Operator Overloading
Example of operator overloading is << operator
Inserts variables or constants on the right to ostream on left
It effectively handles all different types of values on RHS
Bitwise left shift if integer on left
Calls function on the right in case of manipulators
Developer can overload operators to give them a special
meaning
For example, if you have created a structure, then you can overload
operator + to add two variables of that structure by simply writing
statement (s1 + s2), where s1 and s2 are structure variables
Member-access operators (. and .*), conditional operator (?:), scope
resolution operator (::) and sizeof operator can not be overloaded
Interesting reads
Namespace must be existing before it is used with using
directive
https://stackoverflow.com/questions/62876676/c-using-
namespace-directive-for-non-existing-
namespace#62876701
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=29556
https://stackoverflow.com/questions/6841130/ordering-of-
using-namespace-std-and-includes
More about namespaces
https://en.cppreference.com/w/cpp/language/namespace
Sequence point
https://en.wikipedia.org/wiki/
Sequence_point#Sequence_points_in_C_and_C++
