Embed Size (px)
DESCRIPTION
Name lookup (name control). Variables Variable names are searched for in the below order. 1. Locally 2. Class-scope 3. File scope (global). Name lookup (name control). void fun(int x) { { int x = 5; cout
Citation preview
1
Name lookup (name control) Variables
Variable names are searched for in the below order.
1. Locally
2. Class-scope
3. File scope (global)
2
Name lookup (name control)
void fun(int x)
{
{
int x = 5;
cout << x << endl;
}
cout << x << endl;
}
3
Name lookup (name control) Functions Name to match a function is searched
for in the below order.
1. Class-scope (if invoked from an
operation belonging to a class)
2. File-scope
4
Name lookup (name control) Example class-scope
void X::fun() { f(); }
class X
{ //. . .
void f(); // name match
};
The scope operator :: makes it possible to access the desired scope
5
Name lookup (name control) The search for a name match is always
done before the access control.
void f(){. . .} //global function
class X : public B {. . .};
class B
{
//. . .
private:
void f(); // name match
};
void X::fun(){ f(); }
6
Class scope (name control) Enumerations, shared data, and
functions
class Date
{
public:
enum Weekday { MON, TUE, WED, THU, FRI, SAT, SUN };
static int days_per_month[12]; //shared data
static bool is_leap(int); //shared function
//. . .
}
7
Class scope (name control) Declaration of an array with constant size in a class
class Stack
{
//. . .
private:
static const int SIZE = 20; // new proposed feature, still an ERROR with most compilers
static const int SIZE; // OK, but this still does not help array initialization
enum { SIZE = 20 }; // This is the trick
int array[SIZE];
}
const int Stack :: SIZE = 20; //implementation
//initialization
8
Namespaces (name control)
//Declarations
namespace Vendor_A_Containers {
template<class T> class List { . . . };
template<class T> class Queue { . . . };
. . .
}
//Implementation
namespace Vendor_A_Containers {
template<class T> T Queue<T>::remove() { . . . };
template<class T> int Queue<T>::length() const { . . . };
. . .
}
9
Namespaces (name control) Using namespaces//Method 1
//exhaustive
Vendor_A_Containers::Queue<Employee> q;
//The programmer defines an alias.
namespace Cont = Vendor_A_Containers;
Cont::Queue<Employee> q; //BETTER!
10
Namespaces (name control)
Method nr 2
class Bank
{
using Vendor_A_Containers :: Queue;
// . . .
private:
Queue<Customer> waitingQueue;
. . .
}; A using declaration can be put into any scope
11
Namespaces (name control)
#include <stdlib.h> //deprecated To provide backward compatibility with the C
standard library, the <xxx.h> naming is still supported, although it is deprecated.
Use the newer <cxxx>, or <xxx> instead.
#include <cstdlib> //OK
The <cxxx> is used for the old c-headers and the <xxx> is used for the c++-headers.
12
An example//Namespace.h
#ifndef _RS_NAMESPACE_
#define _RS_NAMESPACE_
namespace RS_namespace
{
template <class T>
class List
{
template <class T> class Nod;
public:
typedef Nod<T> nod;
typedef Nod* nod_ptr;
List();
~List();
void ListInsert(T);
//. . .
private:
template <class T>
class Nod
{ public:
T data;
Nod<T>* next;
};
nod_ptr head;
int size;
};
} //end RS_namespace
#endif
13
//List.cpp
#include "RS_namespace.h"
namespace RS_namespace {
//pre: none
//post:a list object is created and initiated
template <class T> List<T>::List()
{
size=0; //sätter storlek på listan till 0
head=NULL;
}
//pre: none
//post:The list object is removed, and memory is returned
template <class T> List<T>::~List()
{
while (!ListIsEmpty())
ListDelete(1);
}
//pre: none
//post:An element is inserted as the first element of the list
template <class T> void List<T>::ListInsert(T newdata)
{
size++;
nod_ptr newptr=new Nod;
newptr->data=newdata;
newptr->next=head; //sätt alltid in först i listan
head=newptr;
}
} //end namespace
14
//main.cpp
#include "RS_namespace.h"
void main()
{
//using just List from RS_namespace
using RS_namespace::List;
//Induce the whole namespace ”RS_namespace”
using namespace RS_namespace;
List<int> myList;
}
15
Access control (name control) Declarations and definitions Example definitions
int x;
Employee lars("Lars");
int square(int x){ return x*x; }
Example declarations
extern int x;
extern Employee lars;
int square();
class Date;
enum Color;
16
Access control (name control) Public, private and protected public
Access is allowed from all clients.
protected Access is allowed from the class itself,
subclasses and friends.
Private Access is allowed from the class itself and
friends.
17
Access control (name control)
Friends - (use with care) A class can declare a function or another class as a friend.
This gives the declared friend(s) total access to the class members.
class Link
{
friend class List;
friend class Queue;
private:
Link() : _next=0 {};
int _info;
Link* _next;
}; When is this useful?
18
Access control Friends (cont...)
The friend keyword is not only telling you that this function is a friend it is also implicitly telling you that it is not a member.
The friend keyword can only be used within a class-definition.
19
Design issues for name control Don’t pollute the global namespace with global
variables. Eliminate them by making them shared data
members of a class. Eliminate global functions by making them
shared class functions. Use a nested class to define a class that are
implementation specific to the class that use it Think carefully before taking a decision about
making a function or class a friend. Do not use protected data!
20
Objects An object is characterized by its:
State Operations Identity
What is a class?
What is object oriented programming?
21
Memory handling A C++ program can allocate memory in
three memory areas:
The run time stack (Automatic storage)
Static storage The heap memory, also called free
storage or dynamic memory.
22
Constructors (memory handling) Every class has four special member
functions: The default constructor The copy-constructor The destructor The assignment operator
23
Generation of default cons.class File
{
private:
string path;
int mode;
public:
File(const string& file_path, int open_mode);
~File();
};
//error, array requires default
//constructor File
File folder1[10];
// error, f2[1] still requires
// default constructor
File folder2[2] = { File("f1", 1)};
//OK, fully nitialized array
folder3[3] = { File("f1", 1), File("f2",2), File("f3",3) };
24
Explicit constructorsclass string
{
public:
string();
//constructors and implicit
//conversion operators
string(int size);
string(const char *);
~string();
private:
int size;
int capacity;
char *buff;
};
25
Explicit constructors What happens in the program below?
int main()
{
string s = "hello"; //OK, convert a
//C-string into a string object
int ns = 0;
s = 1; // 1 oops, programmer
//intended to write ns = 1
}
26
Explicit constructors Solution
class string
{
public:
//block implicit conversion
explicit string(int size);
//implicit conversion
string(const char *);
~string();
};
27
Explicit constructors Solution (cont..)
int main()
{
string s = "hello"; //OK, convert a
//C-string into a string object
int ns = 0;
s = 1; // compile time error, this
//time the compiler catches
//the typo
}
28
Initializing class members There are four different cases to consider
when initializing class members in the constructor.
Initialization of const members. Initialization of alias (reference) members. Initialization of base class members through a
subclass, by sending arguments to the base class constructor.
Initialization of member objects.
In the three first cases an initializer list is mandatory. The fourth case is optional.
29
Copy constructors Why have one?
To copy objects who differ only in identity.
To copy arguments and return values to and from functions, using call-by-value.
When do you absolutely need to define one? All classes with a non trivial
destructor need both a user defined copy-constructor and a user defined assignment operator.
30
Destructors Why have a destructor?
To free resources.
When do I have to define it explicitly? Whenever there is dynamic memory
allocation involved.
Why have a virtual destructor? Whenever the class is a potential
base class.
31
The assignment operator Why have one?
To be able to control what happens when assignment takes place.
When do I need to define one? All classes with a non trivial
destructor need a user defined assignment operator.
Generic form
C& C::operator=(const C&);
32
The assignment operator The assigment operator and the
destructor.// What happens?
List a:
a.insert(. . .);
//. . .
List b;
b.insert(. . .);
//. . .
a = b;
// b goes out of scope
33
The assignment operator
Two problems:
The list a is not removed.
The list b is removed twice!
34
Common factors ... … between the destructor, the copy constructor and
the assignment operator
void List::copy(const List& b)
{
//kod för att kopiera
}
void List::free()
{
//kod för att frigöra minnet
}
List::List(const List& b)
{
copy(b);
}
35
Common factors . . .
List::~List()
{
free();
}
const List& List::operator=( const List& b )
{
if( this != &b)
{
free();
copy(b);
}
return *this;
}
