Transcript Document

1
Capitolo 7: Classi (parte II)
1.
2.
3.
4.
5.
6.
7.
8.
9.
Oggetti const e funzioni membro const
Composizione: oggetti come membri di classi
Funzioni friend e classi friend
Uso del puntatore this
Allocazione dinamica della memoria con new e delete
Membri static
Data abstraction e information hiding
Esempio: dato astratto queue
Classi container e iteratori
Classi proxy
 2000 Prentice Hall, Inc. All rights reserved.
2
1. Oggetti const e funzioni membro const
Principio del minimo privilegio
– dare solo i permessi necessari, non di più
Keyword const
– specifica che un oggetto non è modificabile
– ogni tentativo di modifica genera un errore di sintassi
– esempio
const Time noon( 12, 0, 0 );
dichiara un oggetto costante della classe Time e lo
inizializza a 12
 2000 Prentice Hall, Inc. All rights reserved.
3
Oggetti const richiedono funzioni const
– le funzioni membro dichiarate const non modificano i loro
oggetti
– const deve essere specificato nel prototipo e nella definizione
– prototipo: Type FunctionName(param1,param2…) const;
– definizione: Type FunctionName(param1,param2…) const { …}
– esempio:
int A::getValue() const
{ return privateDataMember };
ritorna il valore di un dato membro, non modifica niente, quindi è
dichiarata const
Costruttori e distruttori non possono essere const
 2000 Prentice Hall, Inc. All rights reserved.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Fig. 7.1: time5.h
4
Outline
// Declaration of the class Time.
// Member functions defined in time5.cpp
#ifndef TIME5_H
#define TIME5_H
class Time {
public:
Time( int = 0, int = 0, int = 0 );
1. Class definition
1.1 Function
prototypes
// default constructor
1.2 Member variables
// set functions
void setTime( int, int, int ); // set time
void setHour( int );
// set hour
void setMinute( int );
// set minute
void setSecond( int );
// set second
// get functions (normally declared const)
int getHour() const;
// return hour
int getMinute() const;
// return minute
int getSecond() const;
// return second
// print functions (normally declared const)
void printMilitary() const; // print military
consttime
void printStandard();
// print standard
time
functions
private:
int hour;
// 0 - 23
int minute;
// 0 - 59
int second;
// 0 - 59
non-const
};
functions

2000 Prentice Hall, Inc. All rights reserved.
#endif
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
// Fig. 7.1: time5.cpp
// Member function definitions for Time class.
#include <iostream>
5
Outline
il costruttore è non-const
using std::cout;
#include "time5.h"
// Constructor function to initialize private data.
// Default values are 0 (see class definition).
Time::Time( int hr, int min, int sec )
{ setTime( hr, min, sec ); }
// Set the values of hour, minute, and second.
void Time::setTime( int h, int m, int s )
{
setHour( h );
setMinute( m );
setSecond( s );
}
// Set the hour value
void Time::setHour( int h )
{ hour = ( h >= 0 && h < 24 ) ? h : 0; }
// Set the minute value
void Time::setMinute( int m )
{ minute = ( m >= 0 && m < 60 ) ? m : 0; }
// Set the second value
void Time::setSecond( int s )
 2000
Prentice Hall,
All rights
{ second
= (Inc.
s >=
0 &&reserved.
s < 60 ) ? s : 0; }
Source Code
1. Load Header
1.1 Function
definitions
64
6
Outline
65 // Get the hour value
66 int Time::getHour() const { return hour; }
67
68 // Get the minute value
69 int Time::getMinute() const { return minute; }
70
71 // Get the second value
72 int Time::getSecond() const { return second; }
Keyword const nella 1.1 Function
definizione e prototipo didefinitions
funzione.
1.2 Purposely leave
out const keyword for
printStandard
73
74 // Display military format time: HH:MM
75 void Time::printMilitary() const
76 {
77
cout << ( hour < 10 ? "0" : "" )
78
<< ( minute < 10 ? "0" : ""
funzioni non-const non possono
usare oggetti const, anche se
<< hour << ":"
non li modificano (come
) << minute;printStandard).
79 }
80
81 // Display standard format time: HH:MM:SS AM (or PM)
82 void Time::printStandard()
// should be const
83 {
84
cout << ( ( hour == 12 ) ? 12 : hour % 12 ) << ":"
85
<< ( minute < 10 ? "0" : "" ) << minute << ":"
86
<< ( second < 10 ? "0" : "" ) << second
87
<< ( hour < 12 ? " AM" : " PM" );
88 
} 2000 Prentice Hall, Inc. All rights reserved.
89 // Fig. 7.1: fig07_01.cpp
90 // Attempting to access a const object with
91 // non-const member functions.
92 #include "time5.h"
93
94 int main()
95 {
96
Time wakeUp( 6, 45, 0 );
// non-constant object
97
const Time noon( 12, 0, 0 );
// constant object
98
99
// MEMBER FUNCTION
OBJECT
100
wakeUp.setHour( 18 ); // non-const
non-const
101
102
noon.setHour( 12 );
// non-const
const
103
104
wakeUp.getHour();
// const
non-const
105
106
noon.getMinute();
// const
const
107
noon.printMilitary(); // const
const
108
noon.printStandard(); // non-const
const
109
return 0;
110 }
7
Outline
1. Initialize variables
2. Attempt to use nonconst functions with
const objects
Compiler errors
Compiling...
Fig07_01.cpp
d:fig07_01.cpp(14) : error C2662: 'setHour' : cannot convert 'this'
pointer from 'const class Time' to 'class Time &'
Conversion loses qualifiers
d:\fig07_01.cpp(20) : error C2662: 'printStandard' : cannot convert
'this' pointer from 'const class Time' to 'class Time &'
Conversion loses qualifiers
Time5.cpp
Error executing cl.exe.
test.exe - 2 error(s), 0 warning(s)
 2000 Prentice Hall, Inc. All rights reserved.
Program Output
8
Sintassi di inizializzatore di membro costante
– costruttore per Increment è modificato:
Increment::Increment( int c, int i )
: increment(i)
{ count = c; }
– : increment(i) initializes increment to i
– tutti i dati membro possono essere inizializzati usando questa
sintassi
– per const e reference si deve usare per forza
– inizializzatori multipli (usa una lista dopo i due punti)
 2000 Prentice Hall, Inc. All rights reserved.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Fig. 7.2: fig07_02.cpp
// Using a member initializer to initialize a
// constant of a built-in data type.
#include <iostream>
9
Outline
1. Class definition
using std::cout;
using std::endl;
class Increment {
public:
Increment( int c = 0, int i = 1 );
void addIncrement() { count += increment; }
void print() const;
private:
int count;
const int increment;
};
1.1 Function
definitions
// const data member
// Constructor for class Increment
Increment::Increment( int c, int i )
: increment( i )
// initializer for const member
{ count = c; }
// Print the data
void Increment::print() const
{
cout << "count = " << count
<< ", increment = " << increment << endl;
}
int main()

{ 2000 Prentice Hall, Inc. All rights reserved.
se provo a inizializzare
increment con un
assegnamento increment = i
è generato un errore.
34
Increment value( 10, 5 );
10
Outline
35
36
cout << "Before incrementing: ";
37
value.print();
1.2 Initialize variables
38
39
for ( int j = 0; j < 3; j++ ) {
2. Function calls
40
value.addIncrement();
41
cout << "After increment " << j + 1 << ": ";
42
value.print();
43
3. Output results
}
44
45
return 0;
46 }
Before incrementing: count
After increment 1: count =
After increment 2: count =
After increment 3: count =
= 10, increment
15, increment =
20, increment =
25, increment =
 2000 Prentice Hall, Inc. All rights reserved.
= 5
5
5
5
11
2. Composizione:
oggetti come membri di classi
Composizione
– una classe ha altre classi come membri
Costruzione degli oggetti
– gli oggetti membri sono costruiti nell’ordine di dichiarazione
– prima della loro inclusione nella nuova classe (host objects)
 2000 Prentice Hall, Inc. All rights reserved.
1
// Fig. 7.4: date1.h
2
// Declaration of the Date class.
3
// Member functions defined in date1.cpp
4
#ifndef DATE1_H
5
#define DATE1_H
12
Outline
1. Class definition
1.1 Member functions
6
7
class Date {
8
public:
9
1.2 Member variables
Date( int = 1, int = 1, int = 1900 ); // default constructor
10
void print() const;
11
~Date();
// print date in month/day/year format
// provided to confirm destruction order
12 private:
13
int month;
// 1-12
14
int day;
// 1-31 based on month
15
int year;
// any year
16
17
// utility function to test proper day for month and year
18
int checkDay( int );
19 };
20
21 
#endif
2000 Prentice Hall, Inc. All rights reserved.
22 // Fig. 7.4: date1.cpp
13
Outline
23 // Member function definitions for Date class.
24 #include <iostream>
25
1. Load header
26 using std::cout;
27 using std::endl;
1.1 Function
definitions
28
29 #include "date1.h"
30
31 // Constructor: Confirm proper value for month;
1.2 Date constructor
32 // call utility function checkDay to confirm proper
33 // value for day.
34 Date::Date( int mn, int dy, int yr )
35 {
36
if ( mn > 0 && mn <= 12 )
37
38
// validate the month
month = mn;
else {
39
month = 1;
40
cout << "Month " << mn << " invalid. Set to month 1.\n";
41
}
42
43
year = yr;
// should validate yr
44
day = checkDay( dy );
// validate the day
45
46
cout << "Date object constructor for date ";
47
print();
48
cout << endl;
49 }
il costruttore stampa
una linea quando è
chiamato.
// interesting: a print with no arguments
50  2000 Prentice Hall, Inc. All rights reserved.
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
// Print Date object in form month/day/year
void Date::print() const
{ cout << month << '/' << day << '/' << year; }
il distruttore stampa
è
// Destructor: provided to confirm destruction order
una linea quando
Date::~Date()
chiamato.
{
cout << "Date object destructor for date ";
print();
cout << endl;
}
// Utility function to confirm proper day value
// based on month and year.
// Is the year 2000 a leap year?
int Date::checkDay( int testDay )
{
static const int daysPerMonth[ 13 ] =
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if ( testDay > 0 && testDay <= daysPerMonth[ month ] )
return testDay;
if ( month == 2 &&
// February: Check for leap year
testDay == 29 &&
( year % 400 == 0 ||
( year % 4 == 0 && year % 100 != 0 ) ) )
return testDay;
cout << "Day " << testDay << " invalid. Set to day 1.\n";
return 1;
// leave object in consistent state if bad value

} 2000 Prentice Hall, Inc. All rights reserved.
14
Outline
1.3 print function
1.4 Date destructor
1.5 checkDay function
84 // Fig. 7.4: emply1.h
15
85 // Declaration of the Employee class.
Outline
86 // Member functions defined in emply1.cpp
87 #ifndef EMPLY1_H
1. Load header
88 #define EMPLY1_H
89
1.1 Class definition
90 #include "date1.h"
91
92 class Employee {
1.2 Member functions
93 public:
94
Employee( char *, char *, int, int, int, int, int, int );
95
void print() const;
96
~Employee();
1.3 Member variables
// provided to confirm destruction order
1.3.1 Include const
variables from Date
class
97 private:
98
char firstName[ 25 ];
99
char lastName[ 25 ];
100
const Date birthDate;
101
const Date hireDate;
102 };
103
104 #endif
 2000 Prentice Hall, Inc. All rights reserved.
composizione – include
altre classi.
105 // Fig. 7.4: emply1.cpp
106 // Member function definitions for Employee class.
107 #include <iostream>
108
109 using std::cout;
110 using std::endl;
111
112 #include <cstring>
113 #include "emply1.h"
114 #include "date1.h"
115
116 Employee::Employee( char *fname, char *lname,
117
int bmonth, int bday, int byear,
118
int hmonth, int hday, int hyear )
119
: birthDate( bmonth, bday, byear ),
120
hireDate( hmonth, hday, hyear )
121 {
122
// copy fname into firstName and be sure that it fits
123
int length = strlen( fname );
124
length = ( length < 25 ? length : 24 );
125
strncpy( firstName, fname, length );
126
firstName[ length ] = '\0';
127
128
// copy lname into lastName and be sure that it fits
129
length = strlen( lname );
130
length = ( length < 25 ? length : 24 );
costruttore
131
strncpy( lastName, lname, length );
una linea
132
lastName[ length ] = '\0';
133
134
cout << "Employee object constructor: "
135
<< firstName << ' ' << lastName << endl;

2000
Prentice
Hall, Inc. All rights reserved.
136 }
16
Outline
1. Load header files
1.1 Function
definitions
1.2 Employee
constructor
1.2.1 Use memberinitializer syntax for
const Date members
stampa
137
17
Outline
138 void Employee::print() const
1.3 print definition
139 {
140
cout << lastName << ", " << firstName << "\nHired: ";
141
hireDate.print();
142
cout << "
143
birthDate.print();
144
cout << endl;
Birth date: ";
1.4 Employee
destructor
la funzione print è const e può
stampare oggetti const.
Print non richiede argomenti, perchè
è linkata all’oggetto che la chiama.
145 }
146
147 // Destructor: provided to confirm destruction order
148 Employee::~Employee()
149 {
150
151
152 }
cout << "Employee object destructor: "
<< lastName << ", " << firstName << endl;
 2000 Prentice Hall, Inc. All rights reserved.
distruttore stampa
una linea.
153 // Fig. 7.4: fig07_04.cpp
18
154 // Demonstrating composition: an object with member objects.
155 #include <iostream>
Outline
1. Load header files
156
157 using std::cout;
2. Create Employee
object
158 using std::endl;
159
2.1 Attempt invalid
Date setting
160 #include "emply1.h"
161
162 int main()
163 {
164
Employee e( "Bob", "Jones", 7, 24, 1949, 3, 12, 1988 );
165
166
cout << '\n';
167
e.print();
168
169
cout << "\nTest Date constructor with invalid values:\n";
170
Date d( 14, 35, 1994 );
171
cout << endl;
172
return 0;
// invalid Date values
173
} 2000 Prentice Hall, Inc. All rights reserved.
Date object constructor for date 7/24/1949
Date object constructor for date 3/12/1988
Employee object constructor: Bob Jones
Jones, Bob
Hired: 3/12/1988
19
Outline
Birth date: 7/24/1949
Test Date constructor with invalid values:
Month 14 invalid. Set to month 1.
Day 35 invalid. Set to day 1.
Date object constructor for date 1/1/1994
Program Output
Date object destructor for date 1/1/1994
Employee object destructor: Jones, Bob
Date object destructor for date 3/12/1988
Date object destructor for date 7/24/1949
Nota come gli oggetti più interni sono creati prima e
disstrutti dopo.
 2000 Prentice Hall, Inc. All rights reserved.
20
3. Funzioni friend e classi friend
Funzioni friend e classi friend
– possono accedere membri private e protected di
un’altra classe
– le funzioni friend non sono funzioni membro della classe
(definite fuori dallo scope)
Proprietà della friendship
– la friendship is concessa, non presa
– non simmetrica (se B è friend di A, A non è friend di
B)
– non transitiva (se A è friend di B, B è friend di C, A
non è friend di C)
 2000 Prentice Hall, Inc. All rights reserved.
21
Dichiarazione friend
– per dichiarare una funzione friend scrivere friend
prima del prototipo della funzione nella classe che sta
concedento la friendship
friend int myFunction(int x);
– per dichiarare una classe friend scrivere friend class
Classname nella classe che sta dando friendship
se ClassOne sta dando friendship a ClassTwo,
friend class ClassTwo;
appare in ClassOne
 2000 Prentice Hall, Inc. All rights reserved.
1
2
// Fig. 7.5: fig07_05.cpp
// Friends can access private members of a class.
3
4
5
6
7
8
#include <iostream>
using std::cout;
using std::endl;
setX friend della classe
Count (accede ai dati
private).
// Modified Count class
21
22
23
24
25
26
int x;
// data member
};
setX non è un membro
di Count.
// Can modify private data of Count because
// setX is declared as a friend function of Count
void setX( Count &c, int val )
cambio di variabili private.
{
c.x = val;
Outline
1. Class definition
1.1 Declare function a
friend
9 class Count {
10
friend void setX( Count &, int ); // friend declaration
11 public:
12
Count() { x = 0; }
// constructor
13
void print() const { cout << x << endl; } // output
14 private:
15
16
17
18
19
20
22
// legal: setX is a friend of Count
}
int main()
{
27
Count counter;
28
29
cout << "counter.x after instantiation: ";
Prentice Hall, Inc. All rights reserved.
30  2000
counter.print();
1.2 Function definition
1.3 Initialize Count
object
31
cout << "counter.x after call to setX friend function: ";
32
setX( counter, 8 );
33
counter.print();
34
return 0;
// set x with a friend
23
Outline
2. Modify object
3. Print results
35 }
counter.x after instantiation: 0
counter.x after call to setX friend function: 8
 2000 Prentice Hall, Inc. All rights reserved.
Program Output
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Fig. 7.6: fig07_06.cpp
// Non-friend/non-member functions cannot access
// private data of a class.
#include <iostream>
using std::cout;
using std::endl;
cannotSetX non è friend
della classe Count. Non accede ai
dati private.
// Modified Count class
class Count {
public:
Count() { x = 0; }
// constructor
void print() const { cout << x << endl; } // output
private:
int x; // data member
};
// Function tries to modify private data of Count,
// but cannot because it is not a friend of Count.
void cannotSetX( Count &c, int val )
{
c.x = val; // ERROR: 'Count::x' is not accessible
}
int main()
{
Count counter;
cannotSetX prova a
modificare i dati
private...
cannotSetX( counter, 3 ); // cannotSetX is not a friend
return 0;

} 2000 Prentice Hall, Inc. All rights reserved.
24
Outline
(Previous program
without friend
declared)
Compiling...
Fig07_06.cpp
D:\books\2000\cpphtp3\examples\Ch07\Fig07_06\Fig07_06.cpp(22) :
error C2248: 'x' : cannot access private member declared in
class 'Count'
D:\books\2000\cpphtp3\examples\Ch07\Fig07_06\
Fig07_06.cpp(15) : see declaration of 'x'
Error executing cl.exe.
test.exe - 1 error(s), 0 warning(s)
compiler error - cannot access
private data
 2000 Prentice Hall, Inc. All rights reserved.
25
Outline
Program Output
26
4. Uso del puntatore this
– consente agli oggetti di accedere al proprio indirizzo
– non è parte dell’oggetto stesso
– Implicit first argument on non-static member function call to the
object
– Implicitly reference member data and functions
– il tipo del puntatore this dipande dal tipo dell’oggetto e se la
funzione membro che usa il this è const
– in una funzione membro non-const di Employee, this ha
tipo
Employee * const
• (puntatore costante a un oggetto Employee)
– in una funzione membro const di Employee, this ha tipo
const Employee * const
• (puntatore costante a un oggetto costate Employee)
 2000 Prentice Hall, Inc. All rights reserved.
27
Chiamate in cascate di funzioni membro
– la funzione ritorna un puntatore reference allo stesso oggetto
{ return *this; }
– altre funzioni possono operare su quel puntatore
– le funzioni che non ritornano references devono essere chiamate
per ultime
 2000 Prentice Hall, Inc. All rights reserved.
28
esempi di chamate in cascata:
– setHour, setMinute, e setSecond ritornano *this
(reference a un oggetto)
– per l’oggetto t, se si considera la chiamata
t.setHour(1).setMinute(2).setSecond(3);
• esegue t.setHour(1), ritorna *this (reference) e
l’espressione diventa t.setMinute(2).setSecond(3);
• esegue t.setMinute(2), ritorna la reference e diventa
t.setSecond(3);
• esegue t.setSecond(3), ritorna la reference e diventa t;
 2000 Prentice Hall, Inc. All rights reserved.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Fig. 7.7: fig07_07.cpp
// Using the this pointer to refer to object members.
#include <iostream>
Test::Test( int a ) { x = a; }
Outline
1. Class definition
using std::cout;
using std::endl;
class Test {
public:
Test( int = 0 );
void print() const;
private:
int x;
};
29
1.1 Function definition
// default constructor
stampa x
// constructor
1.2 Initialize object
2. Function call
stampa x usando l’operatore freccia
required
-> partendo dal puntatore this
void Test::print() const
// ( ) around *this
{
cout << "
x = " << x
<< "\n this->x = " << this->x
<< "\n(*this).x = " << ( *this ).x << endl;
}
int main()
{
Test testObject( 12 );
testObject.print();
return 0;

} 2000 Prentice Hall, Inc. All rights reserved.
stampa x usando l’operatore dot (.).
30
Outline
x = 12
this->x = 12
(*this).x = 12
Program Output
tutti e tre i metodi hanno
lo stesso risultato
 2000 Prentice Hall, Inc. All rights reserved.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Fig. 7.8: time6.h
// Cascading member function calls.
31
Outline
// Declaration of class Time.
// Member functions defined in time6.cpp
#ifndef TIME6_H
#define TIME6_H
class Time {
public:
Time( int = 0, int = 0, int = 0 );
// set functions
Time &setTime( int, int,
Time &setHour( int );
Time &setMinute( int );
Time &setSecond( int );
int );
// set
// set
// set
// default constructor
// set hour, minute, second
hour
minute
nota che le funzioni Time
second
&ritornano una reference a un
oggetto Time.
const)
// get functions (normally declared
int getHour() const;
// return hour
int getMinute() const;
// return minute
int getSecond() const;
// return second
// print functions (normally declared const)
void printMilitary() const; // print military time
void printStandard() const; // print standard time
private:
int hour;
// 0 - 23
int minute;
// 0 - 59
int second;
// 0 - 59
};

2000 Prentice Hall, Inc. All rights reserved.
#endif
1. Class definition
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// Fig. 7.8: time.cpp
// Member function definitions for Time class.
#include <iostream>
#include "time6.h"
// Constructor function to initialize private data.
// Calls member function setTime to set variables.
// Default values are 0 (see class definition).
Time::Time( int hr, int min, int sec )
{ setTime( hr, min, sec ); }
// Set the values of hour, minute, and second.
Time &Time::setTime( int h, int m, int s )
ritornare *this consente la
{
chiamata di funzioni a cascata
setHour( h );
setMinute( m );
setSecond( s );
return *this;
// enables cascading
}
// Set the hour value
Time &Time::setHour( int h )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
}
Outline
1. Load header file
using std::cout;
return *this;
32
// enables cascading
 2000 Prentice Hall, Inc. All rights reserved.
1.1 Function
definitions
65 // Set the minute value
66 Time &Time::setMinute( int m )
67 {
68
69
70
71 }
72
minute = ( m >= 0 && m < 60 ) ? m : 0;
return *this;
// enables cascading
73 // Set the second value
74 Time &Time::setSecond( int s )
75 {
76
second = ( s >= 0 && s < 60 ) ? s : 0;
77
78
return *this;
// enables cascading
79
80
81
82
83
84
}
85
86
87
88
89
90
int Time::getMinute() const { return minute; }
// Get the hour value
int Time::getHour() const { return hour; }
// Get the minute value
// Get the second value
int Time::getSecond() const { return second; }
// Display military format time: HH:MM
91 void Time::printMilitary() const
92 {
93
cout << ( hour < 10 ? "0" : "" ) << hour << ":"
Inc. All<rights
94  2000 Prentice
<< (Hall,
minute
10 reserved.
? "0" : "" ) << minute;
33
Outline
1.1 Function
definitions
ritornare *this consente la
chiamata di funzioni a cascata
95 }
34
96
97 // Display standard format time: HH:MM:SS AM (or PM)
98 void Time::printStandard() const
1.1 Function
99 {
100
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
definitions
101
<< ":" << ( minute < 10 ? "0" : "" ) << minute
-------------------------102
<< ":" << ( second < 10 ? "0" : "" ) << second
1. Load header
103
<< ( hour < 12 ? " AM" : " PM" );
104 }
printStandard non
105 // Fig. 7.8: fig07_08.cpp
1.1 Initialize Time
106 // Cascading member function calls together resturuisce reference
object
107 // with the this pointer
108 #include <iostream>
109
2. Function calls
110 using std::cout;
111 using std::endl;
112
3. Print values
cascading function calls
113 #include "time6.h"
114
115 int main()
printStandard deve essere chiamata dopo
116 {
117
Time t;
setTime perchè printStandard non restituisce una
118
reference.
119
t.setHour( 18 ).setMinute( 30 ).setSecond( 22 );
t.printStandard().setTime(); causa un
120
cout << "Military time: ";
errore.
121
t.printMilitary();
122
cout << "\nStandard time: ";
123
t.printStandard();
124
125
cout << "\n\nNew standard time: ";

2000
Prentice Hall,20,
Inc. 20,
All rights
126
t.setTime(
20 reserved.
).printStandard();
Outline
127
cout << endl;
Outline
128
129
35
return 0;
130 }
Military time: 18:30
Standard time: 6:30:22 PM
New standard time: 8:20:20 PM
 2000 Prentice Hall, Inc. All rights reserved.
Program Output
36
5. Allocazione dinamica della memoria con
new e delete
– usati per l’allocazione dinamica della memoria (superiori a
malloc e free del C)
– new crea un oggetto delle giusta dimensione, chiama il suo
costruttore e ritorna un puntatore del tipo corretto
– delete distrugge l’oggetto e libera spazio
– esempi:
TypeName *typeNamePtr; crea puntatore a un oggetto di
tipo TypeName
typeNamePtr = new TypeName; crea un oggetto di tipo
TypeName, e ritorna un puntatore
 2000 Prentice Hall, Inc. All rights reserved.
37
– esempi
delete typeNamePtr; chiama il distruttore per un
oggetto di tipo TypeName
delete [] arrayPtr; usato per cancellare
dinamicamente un array
Inizializzare oggetti
double *thingPtr = new double(3.14159); inizializza
un oggetto di tipo double a 3.14159
int *arrayPtr = new int[10]; crea un array di 10 interi
 2000 Prentice Hall, Inc. All rights reserved.
38
6. Membri static
Classi membro static
– condivise da tutti gli oggetti di una classe (normalmente ogni
oggetto ha la sua copia di ogni variabile)
– efficienti quando serve una sola copia di un dato (solo la
variabile stati è modificata)
– Simili alle variabili locali, ma sono accessibili solo dagli
oggetti della stessa classe
– esistono anche se non ci sono istanze (oggetti) della classe
– variabili e funzioni possono essere static
– possono essere public, private or protected
 2000 Prentice Hall, Inc. All rights reserved.
39
Variabili static
– accessibili da ogni oggetto
– alle variabili public static si accede usando lo scope
resolution operator(::)
Employee::count
– alle variabili private static si accede via una funzione
membro public static
(To call a public static member
function combine the class name, the :: operator and the
function name Employee::getCount() )
 2000 Prentice Hall, Inc. All rights reserved.
40
Funzioni Static
– funzioni membro static non possono accedere a dati o
funzioni non-static
– non c’è il puntatore this per le funzioni static che
esistono indipendentemente dall’oggetto
 2000 Prentice Hall, Inc. All rights reserved.
1
// Fig. 7.9: employ1.h
2
// An employee class
3
#ifndef EMPLOY1_H
4
#define EMPLOY1_H
1. Class definition
class Employee {
1.1 Function
prototypes
41
Outline
5
6
7 public:
8
Employee( const char*, const char* );
// constructor
9
~Employee();
// destructor
10
const char *getFirstName() const;
// return first name
11
const char *getLastName() const;
// return last name
12
13
// static member function
14
static int getCount();
// return # objects instantiated
15
function membro e
variabile static.
16 private:
17
char *firstName;
18
char *lastName;
19
20
// static data member
21
static int count;
// number of objects instantiated
22 };
23
24 
#endif
2000 Prentice Hall, Inc. All rights reserved.
1.2 Declare variables
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// Fig. 7.9: employ1.cpp
// Member function definitions for class Employee
#include <iostream>
using std::cout;
using std::endl;
#include <cstring>
#include <cassert>
#include "employ1.h"
42
Outline
1. Load header file
il dato membro count e la
funzione membro getCount( )
1.1 Initialize static
sono inizializzati a file scope
data members
(required).
// Initialize the static data member
int Employee::count = 0;
1.2 Function
definitions
// Define the static member function that
// returns the number of employee objects instantiated.
int Employee::getCount() { return count; }
// Constructor dynamically allocates space for the
Nota assert per testare se la memoria è
// first and last name and uses strcpy to copy allocata.
// the first and last names into the object
Employee::Employee( const char *first, const char *last )
{
firstName = new char[ strlen( first ) + 1 ];
assert( firstName != 0 );
// ensure memory allocated
strcpy( firstName, first );
count è cambiato dal costruttore.
lastName = new char[ strlen( last ) + 1 ];
assert( lastName != 0 );
// ensure memory allocated
strcpy( lastName, last );
 2000
Prentice Hall,
All rights reserved.
++count;
//Inc.
increment
static count of employees
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
cout << "Employee constructor for " << firstName
<< ' ' << lastName << " called." << endl;
43
Outline
}
// Destructor deallocates dynamically allocated memory
Employee::~Employee()
{
count
cout << "~Employee() called for " << firstName
<< ' ' << lastName << endl;
delete [] firstName; // recapture memory
delete [] lastName;
// recapture memory
--count; // decrement static count of employees
}
1.2 Function
definitions
è cambiato dal distruttore.
Count decremented
because of destructor
calls from delete.
// Return first name of employee
const char *Employee::getFirstName() const
{
// Const before return type prevents client from modifying
// private data. Client should copy returned string before
// destructor deletes storage to prevent undefined pointer.
return firstName;
}
// Return last name of employee
const char *Employee::getLastName() const
{
// Const before return type prevents client from modifying
// private data. Client should copy returned string before
// destructor deletes storage to prevent undefined pointer.
return lastName;

} 2000 Prentice Hall, Inc. All rights reserved.
88 // Fig. 7.9: fig07_09.cpp
89 // Driver to test the employee class
90 #include <iostream>
91
se non esiste nessun oggetto
1. Initialize
objects
92 usingcount
std::cout;
incrementatodalla
Employee , getCount
deve
93 usingchiamata
std::endl;
di new.
essere acceduto usando class
94
name e ::
2. Function calls
95 #include "employ1.h"
96
Number of employees before instantiation is 0
97 int main()
3. Print data
98 {
99
cout << "Number of employees before instantiation
is "
e2Ptr->getCount()
o
100
<< Employee::getCount() << endl; Employee::getCount().
// use class name
101
102
Employee *e1Ptr = new Employee( "Susan", "Baker" );
103
Employee *e2Ptr = new Employee( "Robert",
"Jones"
);
Number
of employees
after instantiation is 2
104
105
cout << "Number of employees after instantiation is "
106
<< e1Ptr->getCount();
Employee constructor for Susan Baker called.
107
Employee constructor for Robert Jones called.
108
cout << "\n\nEmployee 1: "
109
<< e1Ptr->getFirstName()
110
<< " " << e1Ptr->getLastName()
Employee 1: Susan Baker
111
<< "\nEmployee 2: "
Employee 2: Robert Jones
112
<< e2Ptr->getFirstName()
113
<< " " << e2Ptr->getLastName() << "\n\n";
114
~Employee() called for Susan Baker
115
delete e1Ptr;
// recapture memory
116
e1Ptr = 0;
~Employee() called for Robert Jones
117
delete e2Ptr;
// recapture memory
Prentice
Hall, Inc. All rights reserved.
118 2000
e2Ptr
= 0;
Outline
44
119
120
121
45
cout << "Number of employees after deletion is "
Outline
<< Employee::getCount() << endl;
122
123
return 0;
124 }
count back to zero.
Number of employees before instantiation is 0
Employee constructor for Susan Baker called.
Employee constructor for Robert Jones called.
Number of employees after instantiation is 2
Employee 1: Susan Baker
Employee 2: Robert Jones
~Employee() called for Susan Baker
~Employee() called for Robert Jones
Number of employees after deletion is 0
 2000 Prentice Hall, Inc. All rights reserved.
Program Output
46
7.
Data Abstraction e Information Hiding
Information hiding
– le classi nascondono i dettagli di implementazione
– esempio: stack
• elementi aggiunti (pushed) e rimossi (popped) dal top
• last-in, first-out (LIFO) data structure
• non importa come lo stack è implementato, ma solo la filosofia LIFO
Abstract data types (ADTs)
– modellamo oggetti reali (int, float sono modelli per i numeri)
C++ è estensibile
– i tipi standard non possono essere cambiati, ma possono essere
creati nuovi tipi
 2000 Prentice Hall, Inc. All rights reserved.
47
Esempio: dato astratto queue
Queue
– filosofia FIFO
– Enqueue (mette elementi in coda uno alla volta, dal bottom)
– Dequeue (rimuove gli elementi dalla coda, uno alla volta, dal
top)
Queue ADT
– clients non dovrebbero manipolare direttamente la struttura
– solo le funioni memmbro della coda possono accedere ai dati
interni
 2000 Prentice Hall, Inc. All rights reserved.
48
8.
Classi container e iteratori
Containers
– disegnate per contenere collezioni di oggetti
– forniscono servizi come inserimento, cancellazione, ricerca,
test sugli oggetti, ordinamento
– esempi: array, stack, queue, tree e linked lists
Iteratori
– oggetti che restituiscono il successivo elemento di una
collezione
– è possibile avere più iteratori per container
– ogni iteratore mantiena la propria informazione sulla
posizione
 2000 Prentice Hall, Inc. All rights reserved.
49
9.
Classi proxy
• Proxy class
– Used to hide implementation details of a class
– Class that knows only the public interface of the class being
hidden
– Enables clients to use class’s services without giving access to
class’s implementation
• Forward class declaration
–
–
–
–
Used when class definition only uses a pointer to another class
Prevents the need for including the header file
Declares a class before it is referenced
Format:
class ClassToLoad;
 2000 Prentice Hall, Inc. All rights reserved.
1
// Fig. 7.10: implementation.h
2
// Header file for class Implementation
50
Outline
3
4
class Implementation {
5
public:
6
Implementation( int v ) { value = v; }
7
void setValue( int v ) { value = v; }
8
int getValue() const { return value; }
Implementation has
private data we want to hide.
9
10
11
private:
int value;
Forward class declaration.
12 };
13 // Fig. 7.10: interface.h
14 // Header file for interface.cpp
15 class Implementation;
// forward class declaration
16
17 class Interface {
18
public:
Proxy class Interface has same
public interface as class
Implementation.
19
Interface( int );
20
void setValue( int );
// same public interface as
21
int getValue() const;
// Only
classuses
Implementation
a pointer to class
22
~Interface();
23
24
25
private:
Implementation *ptr;
Implementation. This allows us to
hide the implementation details.
// requires previous
// forward declaration
26 
};2000 Prentice Hall, Inc. All rights reserved.
1. Implementation
class definition
---------------------1. Forward class
declaration
1.1 Interface class
definition
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// Fig. 7.10: interface.cpp
// Definition of class Interface
#include "interface.h"
#include "implementation.h"
51
Outline
Interface::Interface( int v )
: ptr ( new Implementation( v ) ) { }
1. Load header files
1.1 Function
definitions
------------------------contains member functions for proxy class
// call Implementation's getValue function
Interface. It is the only file that has 1. Load interface
int Interface::getValue() const { return ptr->getValue(); }
header file implementation.h, whichheader file
Interface::~Interface() { deletecontains
ptr; } class Implementation.
// Fig. 7.10: fig07_10.cpp
1.1 Initialize objects
// Hiding a class’s private data with a proxy class.
// call Implementation's setValue function
void Interface::setValue( int v Implementation
) { ptr->setValue(
v ); }
file interface.cpp
#include <iostream>
using std::cout;
using std::endl;
#include "interface.h"
int main()
{
Interface i( 5 );
interface.cpp is precompiled2.and
given calls
Function
with the header file interface.h. The
client cannot see the interactions between the
3. Output
proxy class and the proprietary class.
Only the header Interface.h — no mention of class
Implementation. The client never sees the
contains:private
" << i.getValue()
data.
cout << "Interface
<< " before setValue" << endl;
i.setValue( 10 );
cout << "Interface contains: " << i.getValue()
<< " after setValue" << endl;
return 0;

} 2000 Prentice Hall, Inc. All rights reserved.
52
Interface contains: 5 before setVal
Interface contains: 10 after setVal
Outline
Program Output
 2000 Prentice Hall, Inc. All rights reserved.