data structure book in c++ and c in easy wording

1
A Brief Introduction to C++

2
We will provide a brief overview of C++
Many of the statements in C++ are very similar to C#

3
In this topic we will see:
– The similarities between C# and C++
– Some differences, including:
• Global variables and functions
• The preprocessor, compilation, namespaces
• Printing
– Concluding with
• Classes, templates
• Pointers
• Memory allocation and deallocation

4
Control Statements
All control statements are similar
if ( statement ) {
// ...
} else if ( statement ) {
// ... while ( statement ) {
} else { // ...
// ... }
}
for ( int i = 0; i < N; ++i ) {
// ...
do { }
// ...
} while ( statement );

5
Operators
Operators have similar functionality for built-in datatypes:
– Assignment =
– Arithmetic + - * / %
+= -= *= /= %=
– Autoincrement ++
– Autodecrement --
– Logical && || !
– Relational == != < <= >= >
– Comments /* */
// to end of line
– Bitwise & | ^ ~
&= |= ^=
– Bit shifting << >>
<<= >>=

6
Arrays
Accessing arrays is similar:
const int ARRAY_CAPACITY = 10; // prevents reassignment
int array[ARRAY_CAPACITY];
array[0] = 1;
for ( int i = 1; i < ARRAY_CAPACITY; ++i ) {
array[i] = 2*array[i – 1] + 1;
}
Recall that arrays go from 0 to ARRAY_CAPACITY – 1
Definition:
The capacity of an array is the entries it can hold
The size of an array is the number of useful entries

7
Functions
Function calls are similar, however, the are not required to be part of
a class:
#include <iostream>
using namespace std;
// A function with a global name
int sqr( int n ) {
return n*n;
}
int main() {
cout << "The square of 3 is " << sqr(3) << endl;
return 0;
}

8
C++/C# Differences
We will look at categories of differences between C++ and C#:
– Including header files (the preprocessor)
– The file is the base of compilation
– Namespaces
– Printing

9
The C++ Preprocessor
C++ is based on C, which was written in the early 1970s
Any command starting with a # in the first column is not a C/C++
statement, but rather a preprocessor statement
– The preprocessor performed very basic text-based (or lexical)
substitutions
– The output is sent to the compiler

10
The sequence is:
file (filename.cpp) → preprocessor → compiler (g++)
Note, this is done automatically by the compiler: no additional steps
are necessary
At the top of any C++ program, you will see one or more directives
starting with a #, e.g.,
#include <iostream>

11

12
Libraries
You will write your code in a file such as Single_list.h where you
will implement a data structure
This file will be included in our tester file Single_list_tester.h
with a statement such as:
#include "Single_list.h"
The file Single_list_int_driver.cpp then includes the tester file:
#include "Single_list_tester.h"

13
Libraries
You will note the difference:
#include <iostream>
#include "Single_list.h"
The first looks for a file iostream.h which is shipped with the
compiler (the standard library)
The second looks in the current directory

14
Libraries
In this class, you will put all code in the header file
This is not normal practice:
– Usually the header (.h) file only contains declarations
– The definitions (the actual implementations) are stored in a related file
and compiled into an object file

15

16
With all these includes, it is always necessary to avoid the same file
being included twice, otherwise you have duplicate definitions
This is done with guard statements:
#ifndef SINGLE_LIST_H
#define SINGLE_LIST_H
template <typename Type>
class Single_list {
///...
};
#endif

17
This class definition contains only the signatures (or prototypes) of
the operations
The actual member function definitions may be defined elsewhere,
either in:
– The same file, or
– Another file which is compiled into an object file
We will use the first method

18
The File as the Unit of Compilation
Another difference is the unit of compilation
In C#, the class was the basis of compiling executable code:
class TestProgram {
public static void Main() {
System.Console.WriteLine( "Hello World" );
}
}
The existence of a function with the signature
public static void Main();
determines whether or not a class can be compiled into an
executable

19
In C/C++, the file is the base unit of compilation:
– Any .cpp file may be compiled into object code
– Only files containing an int main() function can be compiled into an
executable
The signature of main is:
int main () {
// does some stuff
return 0;
}
The operating system is expecting a return value
– Usually 0

20
This file (example.cpp) contains two functions
#include<iostream>
int sqr( int n ) { // Function declaration and definition
return n*n;
}
int main() {
return 0;
}

21
To compile this file, we execute on the command line:
{ecelinux:1} g++ example.cpp
{ecelinux:2} ls
a.out example.cpp
{ecelinux:3} ./a.out
The square of 3 is 9
{ecelinux:4}

22
This is an alternate form:
#include<iostream>
int sqr( int ); // Function declaration
int main() {
return 0;
}
int sqr( int n ) { // Function definition
return n*n; // The definition can be in another file
}

23
Namespaces
Variables defined:
– In functions are local variables
– In classes are member variables
– Elsewhere are global variables
Functions defined:
– In classes are member functions
– Elsewhere are global functions
In all these cases, the keyword static can modify the scope

24
Namespaces
Global variables/variables cause problems, especially in large
projects
– Hundreds of employees
– Dozens of projects
– Everyone wanting a function init()
In C++ (and XML), this is solved using namespaces

25
Namespaces
A namespace adds an extra disambiguation between similar names
namespace ca_uwaterloo_dwharder {
int n = 4;
double mean = 2.34567;
void init() {
// Does something...
}
}
There are two means of accessing these global variables and
functions outside of this namespace:
– The namespace as a prefix: ca_uwaterloo_dwharder::init()
– The using statement:
using namespace ca_uwaterloo_dwharder;

26
Namespaces
You will only need this for the standard name space
– All variables and functions in the standard library are in the std
namespace
#include <iostream>
std::cout << "Hello world!" << std::endl;
#include <iostream>
using namespace std; // never used in production code
cout << "Hello world!" << endl;

27
Printing
Printing in C++ is done through overloading the << operator:
cout << 3;
If the left-hand argument of << is an object of type ostream (output
stream) and the right-hand argument is a double, int, string,
etc., an appropriate function which prints the object is called

28
Printing
The format is suggestive of what is happening:
– The objects are being sent to the cout (console output) object to be
printed
The objects being printed are:
– a string
– an int
– a platform-independent end-of-line identifier

29
Printing
How does
work?
This is equivalent to
((cout << "The square of 3 is ") << sqr(3)) << endl;
where << is an operation (like +) which prints the object and returns
the cout object

30
Printing
Visually:

31
Printing
Another way to look at this is that
is the same as:
operator<<( operator<<( operator<<( cout, "The square of 3 is " ), sqr(3) ), endl );
This is how C++ treats these anyway...

32
Introduction to C++
The next five topics in C++ will be:
– Classes
– Templates
– Pointers
– Memory allocation
– Operator overloading
With these, you will have (more than) enough information to start
Project 1
– Project 1 is simply the implementation of a few variations of linked lists
(from ECE 150)

33
Classes
To begin, we will create a complex number class
To describe this class, we could use the following words:
– Store the real and imaginary components
– Allow the user to:
• Create a complex number
• Retrieve the real and imaginary parts
• Find the absolute value and the exponential value
• Normalize a non-zero complex number

34
UML Class Diagrams
Instead, another way to summarize the properties of a class is
through UML Class Diagrams
UML, the Unified Modeling Language is a collection of best
practices used in designing/modeling (among other things) software
systems

35
UML Class Diagrams
The Class Diagram for what we describe may be shown as the
following box:

36
UML Class Diagrams
The three components include:
– the name, the attributes, and the operations

37
UML Class Diagrams
The attributes are described by:
– a visibility modifier, a name, and a type

38
UML Class Diagrams
The operations (a.k.a. functions) include:
– a visibility modifier, a name, parameters (possibly with default values)
and return values

39
Classes
An example of a C++ class declaration is:
class Complex {
private:
double re, im;
public:
Complex( double = 0.0, double = 0.0 );
double real() const;
double imag() const;
double abs() const;
Complex exp() const;
void normalize();
};

40
Classes
This only declares the class structure
– It does not provide an implementation
We could, like C#, include the implementation in the class
declaration, however, this is not, for numerous reasons, standard
practice

41
The Complex Class
The next slide gives both the declaration of the Complex class as
well as the associated definitions
– The assumption is that this is within a single file

42
The Complex Class
#ifndef _COMPLEX_H
#define _COMPLEX_H
#include <cmath>
class Complex {
private:
double re, im;
public:
Complex( double = 0.0, double = 0.0 );
// Accessors
double abs() const;
// Mutators
void normalize();
};

43
The Complex Class
// Constructor
Complex::Complex( double r, double i ):
re( r ),
im( i ) {
// empty constructor
}
Associates functions back to the class
Each member variable should be assigned
The order must be the same as the order in which
the member variables are defined in the class
For built-in datatypes, this is a simple assignment.
For member variables that are objects, this is a call
to a constructor.
For built-in datatypes, the above is equivalent to:
// Constructor
Complex::Complex( double r, double i ):re( 0 ), im( 0 ) {
re = r;
im = i;
}

44
The Complex Class
// return the real component
double Complex::real() const {
return re;
}
// return the imaginary component
double Complex::imag() const {
return im;
}
// return the absolute value
double Complex::abs() const {
return std::sqrt( re*re + im*im );
}
Refers to the member variables re and im of this class

45
The Complex Class
// Return the exponential of the complex value
Complex Complex::exp() const {
double exp_re = std::exp( re );
return Complex( exp_re*std::cos(im), exp_re*std::sin(im) );
}

46
The Complex Class
// Normalize the complex number (giving it unit absolute value, |z| = 1)
void Complex::normalize() {
if ( re == 0 && im == 0 ) {
return;
}
double absval = abs();
re /= absval;
im /= absval;
}
#endif
This calls the member function double abs() const
from the Complex class on the object on which
void normalize() was called

47
Visibility
Visibility in C# and Java is described by placing
public/private/protected in front of each class member or member
function
In C++, this is described by a block prefixed by one of
private:
protected:
public:

48
Visibility
class Complex {
private:
double re, im;
public:
Complex( double, double );
double abs() const;
void normalize();
};

49
Visibility
The reason for the change in Java/C# was that the C++ version has
been noted to be a source of errors
Code could be cut-and-paste from one location to another, and a
poorly placed paste could change the visibility of some code:
public → private automatically caught
private → public difficult to catch and dangerous

50
Visibility
It is possible for a class to indicate that another class is allowed to
access its private members
If class ClassX declares class ClassY to be a friend, then class
ClassY can access (and modify) the private members of ClassX

51
Visibility
class ClassY; // declare that ClassY is a class
class ClassX {
private:
int privy; // the variable privy is private
friend class ClassY; // ClassY is a "friend" of ClassX
};
class ClassY { // define ClassY
private:
ClassX value; // Y stores one instance of X
public:
void set_x() {
value.privy = 42; // a member function of ClassY can
} // access and modify the private
}; // member privy of "value"

data structure book in c++ and c in easy wording

More Related Content

Similar to data structure book in c++ and c in easy wording (20)

Recently uploaded (20)

data structure book in c++ and c in easy wording