Referencje i modyfikator const

Transkrypt

Użycie modyfikatora const
Referencja
Przeciążanie operacji czytania i zapisu do strumienia
Bogdan Kreczmer
[email protected]
Zakład Podstaw Cybernetyki i Robotyki
Instytut Informatyki, Automatyki i Robotyki
Politechnika Wrocławska
Kurs: Programowanie obiektowe
c
Copyright2012
Bogdan Kreczmer
Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania obiektowego. Jest on
udostępniony pod warunkiem wykorzystania wyłącznie do własnych prywatnych potrzeb i może on być kopiowany
wyłącznie w całości, razem z niniejszą stroną tytułową.
Programowanie obiektowe
Referencja
Niniejsza prezentacja została wykonana przy użyciu systemu składu LATEX oraz stylu beamer, którego autorem
jest Till Tantau.
Strona domowa projektu Beamer:
http://latex-beamer.sourceforge.net
Referencja
1
Modyfikator const w połączeniu z typem wskaźnikowym
Metody const
2
Referencja
Czym jest referencja
Porównanie – referencje i zmienne wskaźnikowe
3
Zapis i czytanie liczby zepolonej
Czyszczenie bufora – przykład wykorzystania operacji na
strumieniach
Ustawianie precyzji wyświetlania liczb
Referencja
Metody const
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
Metody const
Znaczenie modyfikatora const
Posługując się typem wskaźnikowym możliwe jest zadeklarowanie:
zmiennej wskaźnikowej na modyfikowalny obszar pamięci.
Modyfikator const w połączeniu z typem wskaźnikowym pozwala
na zadeklarowanie:
zmiennej wskaźnikowej na niemodyfikowalny obszar pamięci,
wskaźnika stałego na modyfikowalny obszar pamięci,
wskaźnika stałego na niemodyfikowalny obszar pamięci.
Referencja
Metody const
na zadeklarowanie:
Referencja
Metody const
na zadeklarowanie:
Referencja
Metody const
na zadeklarowanie:
Referencja
Metody const
na zadeklarowanie:
Referencja
Metody const
na zadeklarowanie:
Referencja
Metody const
Przykłady deklaracji zmiennych wskaźnikowych
na zadeklarowanie:
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
→
const char∗ wNapis;
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
→
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
→
→
char∗ const wNapis;
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
→
→
Referencja
Metody const
→ char∗ wNapis;
na zadeklarowanie:
→
→
→
const char∗ const wNapis;
Referencja
Metody const
Deklaracje zmiennych wskaźnikowych z const
char∗
wNapis;
const char∗
wNapis;
char∗ const
wNapis;
const char∗ const
wNapis;
Wskaźnik na tekst, który może być modyfikowany.
Referencja
Metody const
Wskaźnik na modyfikowalny obszar pamięci
char ObszarPam[ ] = ”łódka”;
char∗ wNapis = ObszarPam;
Referencja
Metody const
wNapis[0] = ’w’;
Referencja
Metody const
Referencja
Metody const
char∗ ObszarPam2[ ] = ”udka”;
wNapis = ObszarPam2;
Referencja
Metody const
Podsumowanie:
obszar pamięci dostępny poprzez wskaźnik może być
modyfikowany (dotyczy to operacji z wykorzystaniem tej
zmiennej wskaźnikowej),
zawartość zmiennej wskaźnikowej może ulegać zmianie,
zmienna wskaźnikowa nie musi być inicjalizowana w momencie
jej deklaracji.
Referencja
Metody const
Podsumowanie:
jej deklaracji.
Referencja
Metody const
Podsumowanie:
jej deklaracji.
Referencja
Metody const
Podsumowanie:
jej deklaracji.
Referencja
Metody const
char∗ wNapis;
wNapis = ObszarPam;
...
Podsumowanie:
jej deklaracji.
Referencja
Metody const
char∗
wNapis;
const char∗
wNapis;
char∗ const
wNapis;
const char∗ const
wNapis;
Wskaźnik na tekst, który nie może być modyfikalny.
Referencja
Metody const
Wskaźnik na niemodyfikowalny obszar pamięci
const char∗ wNapis = ObszarPam;
Referencja
Metody const
Referencja
Metody const
P=
P
wNapis[0]
’w’;
P
napis.cpp: In function ‘int main()’:
napis.cpp:22: error: assignment of read-only location ‘* wNapis’
Referencja
Metody const
P=
P
wNapis[0]
’w’;
P
wNapis = ”budka”;
Referencja
Metody const
P=
P
wNapis[0]
’w’;
P
Podsumowanie:
obszar pamięci dostępny poprzez wskaźnik nie może być
modyfikowany (dotyczy to tylko operacji z wykorzystaniem tej
jej deklaracji.
Referencja
Metody const
P=
P
wNapis[0]
’w’;
P
Podsumowanie:
jej deklaracji.
Referencja
Metody const
P=
P
wNapis[0]
’w’;
P
Podsumowanie:
jej deklaracji.
Referencja
Metody const
P=
P
wNapis[0]
’w’;
P
Podsumowanie:
jej deklaracji.
Referencja
Metody const
wNapis = ObszarPam;
P=
P
wNapis[0]
’w’;
P
Podsumowanie:
jej deklaracji.
Referencja
Metody const
Dlaczego czasem coś nie działa
const char∗ wNapis = ”łódka”;
Referencja
Metody const
char∗ wNapis = ”łódka”;
Referencja
Metody const
Takie podstawienie może być zródłem poważnych błędów
Referencja
Metody const
napis.cpp:6: warning: deprecated conversion from string constant to ‘char*’
Referencja
Metody const
Jeżeli jednak zignorujemy ostrzeżenie, to ...
Referencja
Metody const
Segmentation fault (core dumped)
Referencja
Metody const
Segmentation fault (core dumped)
Wystąpienie tego typu błędu zależy od systemu i użytego kompilatora. Nie
zmienia to jednak faktu, że operacja jest niepoprawna.
Referencja
Metody const
char∗
wNapis;
const char∗
wNapis;
char∗ const
wNapis;
const char∗ const
wNapis;
Wskaźnik staly na tekst, który może być modyfikowany.
Referencja
Metody const
Wskaźnik stały na modyfikowalny obszar pamięci
char∗ const wNapis = ObszarPam;
Referencja
Metody const
Referencja
Metody const
Referencja
Metody const
Referencja
Metody const
P=
P
wNapis
”budka”;
P
Referencja
Metody const
P=
P
wNapis
”budka”;
P
Podsumowanie:
modyfikowany,
zawartość zmiennej wskaźnikowej nie może ulegać zmianie,
zmienna wskaźnikowa musi być inicjalizowana w momencie jej
deklaracji.
Referencja
Metody const
P=
P
wNapis
”budka”;
P
Podsumowanie:
modyfikowany,
deklaracji.
Referencja
Metody const
P=
P
wNapis
”budka”;
P
Podsumowanie:
modyfikowany,
deklaracji.
Referencja
Metody const
P=
P
wNapis
”budka”;
P
Podsumowanie:
modyfikowany,
deklaracji.
Referencja
Metody const
PP
P
P=
P
wNapis
ObszarPam;
P
P=
P
wNapis
”budka”;
P
Podsumowanie:
modyfikowany,
deklaracji.
Referencja
Metody const
char∗
wNapis;
const char∗
wNapis;
char∗ const
wNapis;
const char∗ const
wNapis;
Wskaźnik stały na tekst, który nie może być modyfikalny.
Referencja
Metody const
Wskaźnik stały na niemodyfikowalny obszar pamięci
const char∗ const Napis = ”łódka”;
Referencja
Metody const
Podsumowanie
char∗
wNapis
const char∗
wNapis
char∗ const
wNapis
const char∗ const
wNapis
Wskaźnik na tekst, który może być modyfikany.
Referencja
Metody const
Podsumowanie
char∗
wNapis
const char∗
wNapis
char∗ const
wNapis
const char∗ const
wNapis
Wskaźnik na tekst, który nie może być modyfikany.
Referencja
Metody const
Podsumowanie
char∗
wNapis
const char∗
wNapis
char∗ const
wNapis
const char∗ const
wNapis
Wskaźnik stały na tekst, który może być modyfikany.
Referencja
Metody const
Podsumowanie
char∗
wNapis
const char∗
wNapis
char∗ const
wNapis
const char∗ const
wNapis
Wskaźnik stały na tekst, który nie może być modyfikany.
Referencja
Metody const
Konwencja zapisu
char∗
wNapis
const char∗
wNapis
char∗ const
wNapis
const char∗ const
wNapis
Konwencja zapisu deklaracji zmiennej wskaźnikowej
nie jest jednoznaczna.
Referencja
Metody const
Konwencja zapisu
char∗
wNapis
char const∗
wNapis
char∗ const
wNapis
char const∗ const
wNapis
Konwencja zapisu deklaracji zmiennej wskaźnikowej
nie jest jednoznaczna.
Referencja
Metody const
Modyfikator const odgrywa znacznie większą rolę w odniesieniu do
zmiennych wskaźnikowych.
Jego podstawowym miejscem użycia jest lista parametrów funkcji,
np.
char ∗strcpy(char ∗dest, const char ∗src);
(patrz: man strcpy)
Użycie modyfikatora const pozwala wskazać, co może się zmienić
wskutek działania funkcji, a co zmienić się nie może.
Pozwala również uniknąć przypadkowych błędów w konstrukcji samej
funkcji.
Referencja
Metody const
Modyfikator const odgrywa znacznie większą rolę w odniesieniu do
zmiennych wskaźnikowych.
Jego podstawowym miejscem użycia jest lista parametrów funkcji,
np.
char ∗strcpy(char ∗dest, const char ∗src);
(patrz: man strcpy)
Użycie modyfikatora const pozwala wskazać, co może się zmienić
wskutek działania funkcji, a co zmienić się nie może.
Pozwala również uniknąć przypadkowych błędów w konstrukcji samej
funkcji.
Referencja
Metody const
Przykład wykorzystania const w liście parametrów
#include <iostream>
using namespace std;
void WyswietlPomijajacSpacje( const char ∗Napis )
{
for (; ∗Napis && (∗Napis = ’ ’); ++Napis);
cout << Napis << endl;
}
int main( )
{
WyswietlPomijajacSpacje(”
}
Ile jeszcze do końca?”);
Referencja
Metody const
#include <iostream>
{
}
int main( )
{
}
Czy wszystko jest tu dobrze?
Referencja
Metody const
#include <iostream>
void WyswietlPomijajacSpacje( char ∗Napis )
{
}
int main( )
{
}
Przy takiej deklaracji faktycznie program pod względem składni byłby
poprawny. Jednakże jego konstrukcja nie byłaby poprawna.
Referencja
Metody const
#include <iostream>
{
}
int main( )
{
}
Właściwa deklaracja parametrów zapewnia lepszą kontrolę operacji wewnątrz funkcji. Pozwala to wykryć błąd o znaczeniu semantycznym.
Referencja
Metody const
#include <iostream>
{
}
int main( )
{
}
Właściwa deklaracja parametrów zapewnia lepszą kontrolę operacji wewnątrz funkcji. Pozwala to wykryć błąd o znaczeniu semantycznym.
Referencja
Metody const
#include <iostream>
{
}
int main( )
{
}
Komunikat kompilatora:
jkowalsk@noxon: prog> g++ wyswietl.cpp
wyswietl.cpp: In function ’void WyswietlPomijajacSpacje(const char*)’:
wyswietl.cpp:6: error: assignment of read-only location
Referencja
Metody const
#include <iostream>
{
for (; ∗Napis && (∗Napis == ’ ’); ++Napis);
}
int main( )
{
}
Teraz jest już wszystko dobrze.
Referencja
Metody const
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
Metody const
Funkcja działająca na strukturze
struct LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona Z1, LZespolona
{
Z2.re += Z1.re; Z2.im += Z1.im;
return Z2;
}
int main( )
{
LZespolona
}
Z2 )
Arg1, Arg2, Suma;
Suma = dodaj( Arg1, Arg2 );
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
{
Z2.re += Z1.re; Z2.im += Z1.im;
return Z2;
}
int main( )
{
LZespolona
}
Z2 )
Arg1, Arg2, Suma;
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
{
Z2.re += Z1.re; Z2.im += Z1.im;
return Z2;
}
int main( )
{
LZespolona
}
Z2 )
Arg1, Arg2, Suma;
Referencja
Metody const
Od funkcji do metody
struct LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona Z1, LZespolona Z2 )
{
Z2.re += Z1.re; Z2.im += Z1.im;
return Z2;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Suma = dodaj(Arg1, Arg2);
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona ∗wThis, LZespolona Z2 )
{
Z2.re += wThis–>re; Z2.im += wThis –>im;
return Z2;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Suma = dodaj(&Arg1, Arg2);
Referencja
Metody const
float re;
float im;
LZespolona dodaj( LZespolona Z2 );
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::dodaj( LZespolona Z2 )
{
Z2.re += this–>re; Z2.im += this–>im;
return Z2;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Suma = Arg1.dodaj(Arg2);
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona ∗wThis, LZespolona Z2 )
{
Z2.re += wThis–>re; Z2.im += wThis –>im;
return Z2;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Suma = dodaj(&Arg1, Arg2);
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona ∗wThis, LZespolona ∗wZ2 )
{
wZ2–>re += wThis–>re; wZ2–>im += wThis –>im;
return ∗wZ2;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Suma = dodaj(&Arg1, &Arg2);
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona ∗wThis, LZespolona ∗wZ2 )
{
LZespolona Z;
Z.re = wThis–>re + wZ2–>re; Z.im = wThis –>im + wZ2–>im;
return Z;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona dodaj( LZespolona const ∗wThis, LZespolona const ∗wZ2 )
{
LZespolona Z;
return Z;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Referencja
Metody const
float re;
float im;
LZespolona dodaj( LZespolona const ∗wZ2 );
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::dodaj( LZespolona const ∗wZ2 )
{
LZespolona Z;
Z.re = this–>re + wZ2–>re; Z.im = this–>im + wZ2–>im;
return Z;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Suma = Arg1.dodaj(&Arg2);
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
{
LZespolona Z;
return Z;
}
int main( )
{
LZespolona
}
Arg1, Arg2, Suma;
Referencja
Metody const
float re;
float im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
{
LZespolona Z;
return Z;
}
Jak teraz przekszatałcić tę funkcję w metodę?
int main( )
{
LZespolona Arg1, Arg2, Suma;
}
Referencja
Metody const
float re;
float im;
LZespolona dodaj( LZespolona const ∗wZ2 ) const ;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::dodaj( LZespolona const ∗wZ2 ) const
{
LZespolona Z;
Z.re = this–>re + wZ2–>re; Z.im = this–>im + wZ2–>im;
return Z;
}
Modyfikator const przy metodzie sygnalizuje, że nie zmodyfikuje ona obiektu dla
int main( )
którego zostanie wywołana.
{
}
Suma = Arg1.dodaj(&Arg2);
Referencja
Metody const
float re;
float im;
LZespolona dodaj( LZespolona Z2 ) const ;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::dodaj( LZespolona Z2 ) const
{
return Z2;
}
Powróćmy do wersji, gdy drugi argument
przekazywany jest przez wartość.
int main( )
{
}
Suma = Arg1.dodaj(Arg2);
Referencja
Metody const
float re;
float im;
LZespolona operator + ( LZespolona Z2 ) const ;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::operator + ( LZespolona Z2 ) const
{
return Z2;
}
W definicji przeciążenia operatora modyfikator const pełni tę samą funkcję jak w
int main( )
definicji metod.
{
}
Suma = Arg1 + Arg2;
Referencja
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
O referencji
Referencja w C++ jest pochodnym typem danych (podobnie jak
wskaźnik). Umożliwia pośrednie odwoływanie się do zmiennych i
obiektów.
Kłopoty z terminem referencja
w informatyce przez referencję rozumie się pewną ogólną
koncepcję typu danych. Określa się w ten sposób
obiekt/zmienną zawierającą informację będącą odsyłaczem do
właściwej struktury danych. Zmienne wskaźnikowe w C sa
przykładem realizacji koncepcji referencji.
w C++ referencja jest konkretną implementacją typu danych,
który jest istotnie różny od typu wskaźnikowego.
Referencja
O referencji
obiektów.
Referencja
O referencji
obiektów.
Referencja
O referencji
obiektów.
Referencja
Referencja i wskaźnik
W pierwszym przybliżeniu referencja (w C++) może
być uważana jako typ wskaźnikowy stały.
Referencja
int
Licznik;
Dla przykładu rozważmy deklarację zmiennej typu int.
Referencja
int
Licznik;
int* const wskLicznik = &Licznik;
Możemy utworzyć stały wskaźnik na zmienną.
Referencja
int
Licznik;
*wskLicznik = 15;
cerr << Licznik;
Co się wyświetli po wykonaniu przedstawionych
instrukcji?
Referencja
int
Licznik;
int
Licznik;
int
&refLicznik = Licznik;
*wskLicznik = 15;
cerr << Licznik;
Definiując referencję (podobnie jak stały wskaźnik)
należy ją od razu zainicjalizować
Referencja
int
Licznik;
int
Licznik;
int
&refLicznik = Licznik;
*wskLicznik = 15;
cerr << Licznik;
refLicznik = 15;
cerr << Licznik;
Referencją posługujemy się tak samo jak samą
zmienną.
Referencja
char
Znak;
char
Znak;
char* const wskZnak = &Znak;
char
&refZnak = Znak;
*wskZnak = ’a’;
cerr << Znak;
refZnak = ’a’;
cerr << Znak;
Referencją posługujemy się tak samo jak samą
zmienną. Dotyczy to zmiennych każdego typu.
Referencja
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
Referencje versus zmienne wskaźnikowe
Cechy wspólne:
poprzez referencje i wskaźniki odwołujemy się do istniejących
zmiennych/obiektów,
do jednego i tego samego obiektu można utworzyć kilka
zmiennych referencjnych lub zmiennych wskaźnikowych, w
których znajduje się adres tego obiektu,
jeżeli parametr funkcji/metody jest wskaźnikiem lub
referencją, to przekazanie zmiennej poprzez ten parametr
skutkuje tym, że dokonane modyfikacje wartości zmiennej
będą widoczne na zewnątrz funkcji/metod.
Referencja
Cechy wspólne:
Referencja
Cechy wspólne:
Referencja
Cechy wspólne:
Referencja
Różnice:
referencje można zainicjalizowac adresem zmiennej/obiektu
tylko raz, w momencie jej deklaracji,
jest niedopuszczalny brak inicjalizacji referencji,
referencja nie może mieć adresu NULL.
Referencja
Różnice:
Referencja
Różnice:
Referencja
Różnice:
Referencja
Zalety stosowania referencji:
referencja jest bezpieczniejszym sposobem odwołania się do
zmiennej. Nie daje jednak stuprocentowej pewności, że
zmienna/obiekt, do której odwołujemy się przez referencję,
istnieje.
sposób odwołania się do zmiennej/obiektu jest dla
programisty przezroczysty. Referencję traktujemy tak samo
jak zmiennę, do której ta referencja odwołuje się.
odwoływanie się poprzez referencję może pozwalać
kompilatorowi na lepszą optymalizację kodu (brak zmian
przechowywanego adresu).
Referencja
istnieje.
Referencja
istnieje.
Referencja
istnieje.
Referencja
Wady stosowania referencji:
brak elastyczności jaką dają wskaźniki (możliwość zmiany
adresu).
Referencja
Wady stosowania referencji:
brak elastyczności jaką dają wskaźniki (możliwość zmiany
adresu).
Referencja
int Zm;
int & refZm = Zm;
Referencja
int Zm;
int & refZm = Zm;
int Zm;
int ∗ const wskZm = &Zm;
Referencja
int Zm;
int & refZm = Zm;
refZm = 2;
int Zm;
Referencja
int Zm;
int & refZm = Zm;
refZm = 2;
cout << Zm << endl;
int Zm;
Referencja
int Zm;
int & refZm = Zm;
refZm = 2;
cout << Zm << endl;
int Zm;
∗wskZm = 2;
cout << Zm << endl;
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
int Zm;
...
...
...
∗wskZm = 2;
cout << Zm << endl;
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
Jaka wartość zostanie wyświetlona
w tym przypadku?
int Zm;
...
...
...
∗wskZm = 2;
cout << Zm << endl;
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
int Zm;
...
...
...
∗wskZm = 2;
cout << Zm << endl;
w tym przypadku?
A jaka wyświetli się tutaj?
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
int Zm;
...
...
...
∗wskZm = 2;
cout << Zm << endl;
w tym przypadku?
Tego nikt nie wie!!! Gdyż . . .
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
int Zm;
...
(int ∗)wskZm = new int ;
...
∗wskZm = 2;
cout << Zm << endl;
w tym przypadku?
Tego nikt nie wie!!! Gdyż można
wymusić zmianę wskaźnika.
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
w tym przypadku?
int Zm;
...
const cast <int ∗>(wskZm) = new int ;
...
∗wskZm = 2;
cout << Zm << endl;
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
Tu na pewno wyświetli się 2, gdyż
...
int Zm;
...
...
∗wskZm = 2;
cout << Zm << endl;
Referencja
int Zm;
int & refZm = Zm;
...
...
...
refZm = 2;
cout << Zm << endl;
Tu na pewno wyświetli się 2, gdyż
referencja nie może być zmieniona.
int Zm;
...
...
∗wskZm = 2;
cout << Zm << endl;
Referencja
Przekazywanie parametrów przez referencję
void Poteguj(int & Wart)
{
Wart ∗= Wart;
}
int main( )
{
int Zm=2;
Poteguj(Zm);
cout << Zm << endl;
}
Używając referencji możemy poprzez parametr przekazać do funkcji zmiennę, której zmiany wartości będą widoczne na „zewnątrz”.
Referencja
void Poteguj(int & Wart)
{
Wart ∗= Wart;
}
void Poteguj(int ∗ const wWart)
{
∗wWart ∗= ∗wWart;
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
Poteguj(Zm);
cout << Zm << endl;
}
Poteguj(&Zm);
cout << Zm << endl;
}
Analog tej konstrukcji możemy napisać wykorzystując przekazywanie parametru
poprzez wskaźnik.
Referencja
int Poteguj(int & Wart)
{
return Wart ∗ Wart;
}
int Poteguj(int ∗ const wWart)
{
return ∗wWart ∗ ∗wWart;
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
Zm = Poteguj(Zm);
cout << Zm << endl;
}
Zm = Poteguj(&Zm);
cout << Zm << endl;
}
Zapiszmy funkcję Poteguj faktycznie jako funkcje, tzn. procedurę obliczeniową
zwracającą wyliczoną wartość.
Referencja
{
}
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
Zm = Poteguj(2);
cout << Zm << endl;
}
Zm = Poteguj(&Zm);
cout << Zm << endl;
}
Korzystając z funkcji możemy bezpośrednio w liście parametrów posłużyć się stałą
liczbową, zaś wynik przypisać zmiennej.
Referencja
{
}
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
PP
Zm = Poteguj(2
);
P
cout << Zm << endl;
}
Zm = Poteguj(&Zm);
cout << Zm << endl;
}
W tym konkretnym przypadku nie jest to jednak możliwe, gdyż w liście parametrów
występuje referencja do zmiennej.
Referencja
{
}
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
PP
Zm = Poteguj(2
);
P
cout << Zm << endl;
}
Zm = Poteguj(&2);
cout << Zm << endl;
}
A czy analogiczna konstrukcja byłaby poprawna przy przekazaniu parametru przez
wskaźnik?
Referencja
{
}
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
PP
Zm = Poteguj(2
);
P
cout << Zm << endl;
}
PP
Zm = Poteguj(&2
);
P
cout << Zm << endl;
}
Absolutnie NIE!!! Gdyż wskaźnik w tym przykładzie, podobnie jak referencja w
konstrukcji obok, jest wskaźnikiem na obszar modyfikowalny.
Referencja
{
}
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
PP
Zm = Poteguj(2
);
P
cout << Zm << endl;
}
PP
Zm = Poteguj(&2
);
P
cout << Zm << endl;
}
Czy naprawdę nic się nie da tu zrobić?
Referencja
int Poteguj(const int & Wart)
{
}
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
Zm = Poteguj(2);
cout << Zm << endl;
}
PP
Zm = Poteguj(&2
);
P
cout << Zm << endl;
}
W przypadku parametru przekazywanego przez referencję wystarczy, że parametr
ten zadeklarujemy jako parametr niemodyfikowalny.
Referencja
{
}
int Poteguj(const int ∗ const wWart)
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
Zm = Poteguj(2);
cout << Zm << endl;
}
Zm = Poteguj(&2); ???
cout << Zm << endl;
}
Można by sądzić (naiwnie), że analogiczna konstrukcja będzie również poprawna
w przypadku parametrów przekazywanych przez wskaźnik.
Referencja
{
}
int Poteguj(const int ∗ const wWart)
{
}
int main( )
{
int Zm=2;
int main( )
{
int Zm=2;
Zm = Poteguj(2);
cout << Zm << endl;
}
PP
Zm = Poteguj(&2
);
P
cout << Zm << endl;
}
Tak jednak nie jest. Nie można posługiwać się jawnymi adresami do stałych skalarnych, gdyż nie muszą się one w ogóle znajdować w obszarze danych programu.
Referencja
Przekazywanie parametrów do funkcji
Pascal
C
C++
wartość
wskaźnik
Podstawowymi sposobami przekazania parametrów do funkcji/procedury, jest przekazanie przez wartość i wskaźnik. Tego typu mechanizmy są dostępne zarówno w
języku C, jak też C++ oraz starszych językach takich jak, np. Pascal.
Referencja
Pascal
wartość
procedure Proc(Li :integer);
C
void Fun(int Li);
C++
void Fun(int Li);
wskaźnik
Przekazywanie parametru wywołania przez wartość powoduje tworzenie jego kopii.
Dzięki temu modyfikacje wartości parametru wewnątrz funkcji nie są „widoczne”
na zewnątrz.
Referencja
Przekazywanie parametrów przez wartość
#include <iostream>
float Poteguj(float Li)
{
Li ∗= Li;
return Li;
}
int main( )
{
float Zm = 2, Wynik = 0;
cout << ”Przed: ” << Zm
<< endl;
Wynik = Poteguj(Zm);
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
”Wynik: ” << Wynik << endl;
Jako przykład rozważmy prostą funkcję.
Referencja
#include <iostream>
{
Li ∗= Li;
return Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
Funkcja Poteguj modyfikuje wewnątrz wartość parametru formalnego Li. Jednak
zmiany nie mogą mieć wpływu na wartość rzeczywistego parametru Zm w wywołaniu tej funkcji. Tak więc to co wyświetli ten program to . . .
Referencja
#include <iostream>
{
Li ∗= Li;
return Li;
}
int main( )
{
jk@diablo> ./prog
Przed: 2
Po: 2
Wynik: 4
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
. . . to będzie to co powyżej :)
Referencja
Pascal
wartość
C
void Fun(int Li);
C++
void Fun(int Li);
wskaźnik
Drugim wariantem przekazywania parametrów do funkcji jest użycie wskaźnika.
Referencja
Pascal
C
C++
wartość
void Fun(int Li);
void Fun(int Li);
wskaźnik
procedure Proc(wLi :ˆinteger);
void Fun(int∗ wLi);
Wykorzystanie jako parametru formalnego wskaźnika pozwala na dokonanie przez
funkcję modyfikacji w obszarze pamięci procesu, które będą „widoczne” po zakończeniu działania funkcji.
Referencja
Przekazywanie parametrów przez wskaźnik
#include <iostream>
void PotegujParametr(float ∗wLi)
{
∗wLi ∗= ∗wLi;
}
int main( )
{
float Zm = 2;
cout << ”Przed: ”
<<
Zm
<< endl;
Zm
<< endl;
PotegujParametr(&Zm);
}
cout
<<
”
Po: ”
<<
Np. rozważmy ponownie prosty przykład.
Referencja
#include <iostream>
{
∗wLi ∗= ∗wLi;
}
int main( )
{
float Zm = 2;
<<
Zm
<< endl;
Zm
<< endl;
}
cout
<<
”
Po: ”
<<
Funkcja PotegujParametr wykorzystując jako parametr formalny wskaźnik wLi
dokonuje modyfikacji zawartości zmiennej Zm. Tak więc to co się wyświetli to . . .
Referencja
#include <iostream>
jk@diablo> ./prog
Przed: 2
Po: 4
{
∗wLi ∗= ∗wLi;
}
int main( )
{
float Zm = 2;
<<
Zm
<< endl;
}
cout
<<
”
Po: ”
<<
Zm
<< endl;
Funkcja PotegujParametr wykorzystując jako parametr formalny wskaźnik wLi
dokonuje modyfikacji zawartości zmiennej Zm. Tak więc to co się wyświetli to
widać powyżej.
Referencja
Pascal
C
C++
wartość
void Fun(int Li);
void Fun(int Li);
wskaźnik
zmiennę/
referencję
Język C++ dostarcza alternatywny sposób przekazywania parametrów z możliwością modyfikacji ich wartości, tak aby były one widoczne na „zewnątrz”.
Referencja
Pascal
C
C++
wartość
void Fun(int Li);
void Fun(int Li);
wskaźnik
zmiennę/
referencję
procedure Proc(var Li :integer);
—
void Fun(int& Li);
Tym sposobem jest przekazywanie parametru przez referencję. Jest to de facto przekazanie przez wskaźnik. Niemniej zapis jest prostszy i daje potencjalne możliwości
lepszej optymalizacji kodu.
Referencja
Przekazywanie parametrów przez referencję do zmiennej
#include <iostream>
void PotegujParametr(float &Li)
{
Li ∗= Li;
}
int main( )
{
float Zm = 2;
<<
Zm
<< endl;
Zm
<< endl;
PotegujParametr(Zm);
}
cout
<<
”
Po: ”
<<
Rozważmy prosty przykład.
Referencja
#include <iostream>
{
Li ∗= Li;
}
int main( )
{
float Zm = 2;
<<
Zm
<< endl;
Zm
<< endl;
}
cout
<<
”
Po: ”
<<
Program zawiera funkcję, która modyfikuje zawartość parametru formalnego. Jak
łatwo się domyśleć wynik działania programu będzie . . .
Referencja
#include <iostream>
jk@diablo> ./prog
Przed: 2
Po: 4
{
Li ∗= Li;
}
int main( )
{
float Zm = 2;
<<
Zm
<< endl;
}
cout
<<
”
Po: ”
<<
Zm
<< endl;
Program zawiera funkcję, która modyfikuje zawartość parametru formalnego. Jak
łatwo się domyśleć wynik działania programu będzie identyczny jak w przykładzie
ze wskaźnikami.
Referencja
Pascal
C
C++
wartość
void Fun(int Li);
void Fun(int Li);
wskaźnik
zmiennę/
referencję
—
void Fun(int& Li);
referencję
const
Unikalnym mechanizmem języka C++ (w kontekście niniejszego zestawienia) jest
przekazywanie parametru poprzez referencję do zmiennej (lub też stałej), która nie
może być modyfikowana.
Referencja
Pascal
C
C++
wartość
void Fun(int Li);
void Fun(int Li);
wskaźnik
zmiennę/
referencję
—
void Fun(int& Li);
referencję
const
—
—
void Fun(const int& Li);
Sposób ten czyni program bardziej przejrzystym i pozwala lepiej odczytać intencje
programisty. Zapis taki sygnalizuje, że zawartość parametru nie ulegnie zmianie po
zakończeniu działania funkcji.
Referencja
Przekazywanie parametrów przez referencję do stałej
#include <iostream>
float Poteguj(const float &Li)
{
return Li ∗= Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
Ponownie rozważmy prosty przykład.
Referencja
#include <iostream>
{
return Li ∗= Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
Zawiera on funkcję, do której parametr przekazywany jest przez referencję. Można
się domyśleć, że program wyświetli . . .
Referencja
#include <iostream>
{
return Li ∗= Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
Program nic nie wyświetli!!! Gdyż w programie jest błąd! Gdzie?
Referencja
#include <iostream>
{
return Li ∗= Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
prog.cpp: In function ‘float Poteguj(const float&)’:
prog.cpp:6: error: assignment of read-only reference ‘Li’
Referencja
#include <iostream>
{
return Li ∗= Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
W funkcji Poteguj następuje niedozwolona modyfikacja parametru. W tym przypadku kompilator pomaga nam wykryć przypadkowy błąd.
Referencja
#include <iostream>
{
return Li ∗ Li;
}
int main( )
{
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
Teraz jest już dobrze. A więc jak można się domyśleć wyświetli się . . .
końca nie wiadomo czy na pewno ;)
(choć nigdy do
Referencja
#include <iostream>
{
return Li ∗ Li;
}
int main( )
{
jk@diablo> ./prog
Przed: 2
Po: 2
Wynik: 4
<< endl;
}
cout
cout
<<
<<
” Po: ” << Zm << endl;
Teraz jest już dobrze. A więc jak można się domyśleć wyświetli się to samo co w
przykładzie z przekazywaniem parametru przez wartość.
Referencja
Pascal
C
C++
wartość
void Fun(int Li);
void Fun(int Li);
wskaźnik
zmiennę/
referencję
—
void Fun(int& Li);
referencję
—
—
void Fun(const int& Li);
Język C++ daje większą elastyczność, a zarazem pozwala lepiej kontrolować sposób dostępu do przekazywanych parametrów.
Referencja
Czyszczenie bufora – przykład wykorzystania operacji na strumienia
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
Operacje wyświetlania dla własnej struktury
struct
};
LiczbaZespolona {
float re, im;
ostream & operator << ( ostream & StrmWy, LiczbaZespolona Lz )
{
return StrmWy << Lz.re << showpos << Lz.im << noshowpos
}
int main( )
{
LiczbaZespolona LZesp;
LZesp.re = 2; LZesp.im = 5;
}
cout
<< ”Liczba zespolona: ” << LZesp << endl;
Dla części urojonej wymuszone zostaje uwidocznienie znaku liczby.
<< ’i’;
Referencja
struct
};
LiczbaZespolona {
float re, im;
{
}
int main( )
{
}
cout
Wyświetlona wartość:
2+5i
Dla części urojonej wymuszone zostaje uwidocznienie znaku liczby.
<< ’i’;
Referencja
Operacje zapisu do pliku
struct
};
LiczbaZespolona {
float re, im;
{
return StrmWy << Lz.re << showpos << Lz.im << noshowpos << ’i’;
}
int main( )
{
W analogiczny sposób możemy daną
ofstream
PlikWy;
liczbę zapisać do pliku.
PlikWy.open(”nowy test.txt”);
Pamiętać jedynie należy aby dołączyć
if (!PlikWy.is open()) return 1;
plik nagłówkowy fstream.
PlikWy << ”Liczba zespolona: ” << LZesp << endl;
if (PlikWy.fail()) cout << ”Blad operacji czytania\n”;
PlikWy.close();
}
Referencja
Operacje zapisu do pliku
struct
};
LiczbaZespolona {
float re, im;
{
}
int main( )
{
W analogiczny sposób możemy daną
ofstream
PlikWy;
liczbę zapisać do pliku.
PlikWy.open(”nowy test.txt”);
Pamiętać jedynie należy aby dołączyć
if (!PlikWy.is open()) return 1;
plik nagłówkowy fstream.
PlikWy << ”Liczba zespolona: ” << LZesp << endl;
if (PlikWy.fail()) cout << ”Blad operacji czytania\n”;
PlikWy.close();
}
Referencja
struct
};
LiczbaZespolona {
float re, im;
{
}
<< ’i’;
int main( )
{
}
cout
2+5i
Czy w tym przypadku jedynym możliwym sposobem przekazania parametru jest
przekazanie go przez wartość?
Referencja
struct
};
LiczbaZespolona {
float re, im;
ostream & operator << ( ostream & StrmWy, const LiczbaZespolona &Lz )
{
}
int main( )
{
}
cout
2+5i
Można go również przekazać przez referencję do obiektu stałego. W tym konkretnym
przypadku jest to bardziej właściwe.
Referencja
Operacje czytania dla własnej struktury
struct
};
LiczbaZespolona {
float re, im;
istream & operator
{
...
}
>> ( istream & StrmWy, LiczbaZespolona & Lz )
int main( )
{
cin >> LZesp;
}
Natomiast dla tego przypadku przekazywanie parametru przez referencję jest
konieczne. Musi to być jednak referencja do obiektu modyfikowalnego.
Referencja
struct
LiczbaZespolona { float re, im; };
istream & operator >> ( istream & StrmWe, LiczbaZespolona & Lz )
{
StrmWe >> lz.re;
StrmWe >> lz.im;
StrmWe.ignore( );
return StrmWe;
Wczytywana liczba:
}
2+5i
int main( )
{
...
}
Prezentowana implementacja czytania liczby zespolonej jest bardzo uproszczona (brak
reakcji na błędy). Realizacja czytania: wczytane zostają dwie kolejne liczby, następnie
zostaje pominięty pierwszy znak znajdujący się za drugą liczbą.
Referencja
struct
{
StrmWe >> lz.re;
StrmWe >> lz.im;
StrmWe.ignore( );
return StrmWe;
Wczytywana liczba:
}
Napis+5i
int main( )
{
cin >> LZesp;
if ( cin.fail() ) {
cerr << ”Blad formatu liczby zespolonej”
}
}
<<endl;
Referencja
struct
{
StrmWe >> lz.re; Jeśli ta operacja nie powiedzie się, to następne również.
StrmWe >> lz.im;
StrmWe.ignore( );
return StrmWe;
Wczytywana liczba:
}
Napis+5i
int main( )
{
cin >> LZesp;
if ( cin.fail() ) {
}
}
<<endl;
Referencja
struct
{
StrmWe >> lz.re; Jeśli ta operacja nie powiedzie się, to następne również.
StrmWe >> lz.im;
StrmWe.ignore( );
return StrmWe;
Wczytywana liczba:
}
Napis+5i
int main( )
{
cin >> LZesp;
if ( cin.fail() ) {
cerr << ”Blad formatu liczby zespolonej” <<endl;
cin.clear( );
Aby móc ewentualnie czytać dalej.
}
}
Referencja
struct
{
StrmWe >> lz.re >> lz.im; Bardziej zwarty zapis, taki sam efekt końcowy.
StrmWe.ignore( );
return StrmWe;
}
Wczytywana liczba:
Napis+5i
int main( )
{
cin >> LZesp;
if ( cin.fail() ) {
cin.clear( );
}
}
<<endl;
Referencja
Sygnalizacja błędu
struct
{
StrmWe >> lz.re >> lz.im;
...
char Znak;
StrmWe >> Znak;
...
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5i
Referencja
struct
{
...
Właściwe wczytanie liczby zespolonej wymaga
char Znak;
sprawdzenia poprawności oznaczenia części urojonej.
StrmWe >> Znak;
if (Znak != ’ i ’) { . . . }
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5Z
Referencja
struct
{
...
Dobrze jest, gdy reakcja na błąd jest zgodna z ogólnie
char Znak;
przyjętą konwencją. Należy więc ustawić flagę fail ...
StrmWe >> Znak;
if (Znak != ’ i ’) { StrmWe.setstate(ios::failbit); }
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5Z
Referencja
struct
{
...
... wcześniej jednak należy zwrócić wczytany znak. Dlachar Znak;
czego należy to zrobić i dlaczego to musi być wcześniej?
StrmWe >> Znak;
if (Znak != ’ i ’) { StrmWe.unget(); StrmWe.setstate(ios::failbit); }
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5Z
Referencja
struct
{
...
Jednak wczytanie znaku również może się nie powieść.
char Znak;
StrmWe >> Znak;
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5
Referencja
struct
{
...
Można to rozwiązać w ten sposób.
char Znak;
StrmWe >> Znak;
if ( StrmWe.fail() ) return StrmWe;
return StrmWe;
Wczytywana liczba:
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
2+5
Referencja
struct
{
...
A można to rozwiązać również w ten sposób.
char Znak = ’x’;
(Dlaczego?)
StrmWe >> Znak;
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5
Referencja
struct
{
StrmWe >> Znak;
return StrmWe;
}
Wczytywana liczba:
2+5i
int main( )
{
cin >> LZesp;
Przed operacją czytania należy sprawdzić, wynik
if ( cin.fail() ) { . . .
wcześniejszej operacji i podjąć odpowiednie działania.
...
Referencja
struct
{
StrmWe >> Znak;
return StrmWe;
}
Wczytywana liczba:
2+5i
int main( )
{
cin >> LZesp;
Czy można tę operację pominąć?
if ( cin.fail() ) { . . .
...
Referencja
struct
{
StrmWe >> Znak;
return StrmWe;
}
Wczytywana liczba:
2+5i
int main( )
{
cin >> LZesp;
Można, pod warunkiem, że właściwie zainicjalizujemy
if ( cin.fail() ) { . . .
zmiennę Zm. (Dlaczego?)
...
Referencja
struct
{
StrmWe >> Znak;
return StrmWe;
}
Wczytywana liczba:
2+5i
int main( )
{
cin >> LZesp;
Można również nie rezygnować ze sprawdzenia poprawności
if ( cin.fail() ) { . . .
wczytania liczb i całość zapisać w bardziej zwarty sposób.
...
Referencja
struct
{
Czy jednak trzeba w ogóle wczytwać znak
...
’i’ ? Czy nie można tego rozwiązać
...
prościej?
...
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5i
Referencja
struct
{
if (StrmWe.peek( ) != ’ i ’) { StrmWe.setstate(ios::failbit); return StrmWe;}
...
Można bez wczytywania sprawdzić jaki znak jest
...
na początku strumienia wejściowego.
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5i
Referencja
struct
{
StrmWe.ignore( );
Jeżeli wszystko jest dobrze, to możemy ten znak
...
przeskoczyć.
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5i
Referencja
struct
{
StrmWe.ignore( );
I to już wystarczy.
return StrmWe;
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5i
Referencja
struct
{
StrmWe.ignore( );
Można jeszcze bardziej skrócić i zagęścić ten
return StrmWe;
zapis, ale to już przy innej okazji.
}
int main( )
{
cin >> LZesp;
if ( cin.fail() ) { . . .
...
Wczytywana liczba:
2+5i
Referencja
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
Przykładowy problem
Jak wyczyścić bufor klawiatury?
Referencja
Rozwiązanie – przynajmniej częściowe
Problem czyszczenia buforu klawiatury można częściowo
rozwiązać wykorzystująć metodę ignore.
istream& istream::ignore( streamsize n = 1, int delim = EOF );
Referencja
cin.ignore(1000,’\n’);
W ten sposób pominiemy wszystkie znaki, o ile jest ich
nie więcej niż 999. Operacja zostanie wykonana dopiero
po naciśnięciu klawisza Enter (dlaczego?).
Referencja
cin.ignore(1000,’\n’);
A co zrobić gdy mamy upartego użytkownika, który wprowadzi więcej znaków?
Referencja
cin.ignore( numeric limits<streamsize>::max( ), ’\n’);
Można dać jako ograniczenie maksymalny rozmiar strumienia!!!
Referencja
Właściwe użycie metody ignore
#include<iostream>
#include<limits>
...
cin.ignore( numeric limits<streamsize>::max( ), ’\n’);
Aby wszystko było dobrze, nie można zapomnieć o wcześniejszym dołączeniu właściwych plików nagłówkowych.
Referencja
Plan prezentacji
1
Metody const
2
Referencja
3
strumieniach
Referencja
Manipulator setprecision(.)
Manipulator setprecision(.) pozwala ustawić ilość
wyświetlanych znaczących cyfr danej liczby.
Działanie takie odnosi się do domyślnego formatu
wyświetlania liczb zmiennoprzecinkowych.
Referencja
Przykład użycia manipulatora setprecision(.)
int main()
{
float fLiczba = 123.456789;
int
iDomyslnaPrecyzja = cout.precision();
}
cout
<< ”
<< fLiczba << endl;
cout
<< ”Domyslny format po zmianie precyzji: ”
<< setprecision(4) << fLiczba << endl;
cout
<< ”
Powrot do formatu domyslnego: ”
<< setprecision(iDomyslnaPrecyzja)
<< fLiczba << endl; Konsola:
Domyslny format: ”
Domyslny format: 123.457
Domyslny format po zmianie precyzji: 123.5
Powrot do formatu domyslnego: 123.457
Referencja
Stały przecinek
Notację dzisiętną ze stała ilością cyfr po przecinku
możemy uzyskać wykorzystując manipulator fixed.
Manipulator setprecision(.) pozwala wówczas
określić ilość cyfr po przecinku, które zostaną
wyświetlone.
Referencja
Przykład użycia manipulatora fixed
int main()
{
float fLiczba = 123.456789;
int
iDomyslnaPrecyzja = cout.precision();
}
cout
<< ” Ustalona liczba cyfr po przecinku: ”
<< setprecision(4) << fixed << fLiczba << endl;
cout
<< ”
Powrot do formatu domyslnego: ”
<< setprecision(iDomyslnaPrecyzja)
<< resetiosflags(ios::fixed)
<< fLiczba << endl;
Konsola:
Ustalona liczba cyfr po przecinku: 123.5678
Powrot do formatu domyslnego: 123.457
Referencja
Koniec prezentacji

Referencje i modyfikator const

Transkrypt

Podobne dokumenty

Termodynamika techniczna 2015 nr1

Zadanie 1 Wyznaczyć przemieszczenie pionowe punk Zadanie 2

78. Ruch cząstek naładowanych w polu elektrycznym.

U = V

Ćwiczenia do wykładu Fizyka Statystyczna i Termodynamika

liczby wymierne - Instytut Informatyki Uniwersytetu

laboratorium maszyn elektrycznych i transformatorów