name lookup (name control)
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; coutTRANSCRIPT
![Page 1: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/1.jpg)
1
Name lookup (name control) Variables
Variable names are searched for in the below order.
1. Locally
2. Class-scope
3. File scope (global)
![Page 2: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/2.jpg)
2
Name lookup (name control)
void fun(int x)
{
{
int x = 5;
cout << x << endl;
}
cout << x << endl;
}
![Page 3: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/3.jpg)
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
![Page 4: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/4.jpg)
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
![Page 5: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/5.jpg)
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(); }
![Page 6: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/6.jpg)
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
//. . .
}
![Page 7: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/7.jpg)
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
![Page 8: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/8.jpg)
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 { . . . };
. . .
}
![Page 9: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/9.jpg)
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!
![Page 10: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/10.jpg)
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
![Page 11: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/11.jpg)
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.
![Page 12: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/12.jpg)
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
![Page 13: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/13.jpg)
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
![Page 14: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/14.jpg)
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;
}
![Page 15: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/15.jpg)
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;
![Page 16: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/16.jpg)
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.
![Page 17: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/17.jpg)
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?
![Page 18: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/18.jpg)
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.
![Page 19: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/19.jpg)
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!
![Page 20: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/20.jpg)
20
Objects An object is characterized by its:
State Operations Identity
What is a class?
What is object oriented programming?
![Page 21: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/21.jpg)
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.
![Page 22: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/22.jpg)
22
Constructors (memory handling) Every class has four special member
functions: The default constructor The copy-constructor The destructor The assignment operator
![Page 23: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/23.jpg)
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) };
![Page 24: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/24.jpg)
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;
};
![Page 25: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/25.jpg)
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
}
![Page 26: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/26.jpg)
26
Explicit constructors Solution
class string
{
public:
//block implicit conversion
explicit string(int size);
//implicit conversion
string(const char *);
~string();
};
![Page 27: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/27.jpg)
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
}
![Page 28: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/28.jpg)
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.
![Page 29: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/29.jpg)
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.
![Page 30: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/30.jpg)
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.
![Page 31: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/31.jpg)
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&);
![Page 32: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/32.jpg)
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
![Page 33: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/33.jpg)
33
The assignment operator
Two problems:
The list a is not removed.
The list b is removed twice!
![Page 34: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/34.jpg)
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);
}
![Page 35: Name lookup (name control)](https://reader036.vdocuments.net/reader036/viewer/2022062314/56814acc550346895db7e2d7/html5/thumbnails/35.jpg)
35
Common factors . . .
List::~List()
{
free();
}
const List& List::operator=( const List& b )
{
if( this != &b)
{
free();
copy(b);
}
return *this;
}