Wartosci domyslne i przeciazenia

Transkrypt

Rozszerzenia C++ względem C
Przeciążenia funkcji, metod i operatorów
Wartości domyślne i przeciążenia
Bogdan Kreczmer
[email protected]
Zakład Podstaw Cybernetyki i Robotyki
Instytut Informatyki, Automatyki i Robotyki
Politechnika Wrocławska
Kurs: Programowanie obiektowe
c
Copyright°2010
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
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
1
Wartości domyślne
Pliki nagłówkowe
Wartości domyślne parametrów metod
2
Przeciążenia (przeładowanie) funkcji
Przeciążenia (przeładowanie) metod
Wartości domyślne
Pliki nagłówkowe
Cel
Zbudujmy program, który umożliwi wyliczanie współrzędnych punktów dla rodziny parabol:
Wartości domyślne
Pliki nagłówkowe
Cel
Wartości domyślne
Pliki nagłówkowe
Cel
Wartości domyślne
Pliki nagłówkowe
Cel
Ogólna postać równania:
y = ax 2 + b
Wartości domyślne
Pliki nagłówkowe
Implementacja
float Parabola(float x, float a, float b)
{
return a∗x∗x+b;
}
Wartości domyślne
Pliki nagłówkowe
Implementacja
float Parabola(float x, float a, float b)
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,1,0);
Wartości domyślne
Pliki nagłówkowe
Definiowanie wartości domyślnych
float Parabola(float x, float a, float b = 0)
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
Wartości domyślne
Pliki nagłówkowe
Korzystanie z wartości domyślnych
float Parabola(float x, float a, float b = 0)
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,1);
Wartości domyślne
Pliki nagłówkowe
float Parabola(float x, float a, float b= 0)
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,1); // ⇒ Parabola(x,1,0)
Wartości domyślne
Pliki nagłówkowe
float Parabola(float x, float a = 1, float b= 0)
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,1);
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x);
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x); // ⇒ Parabola(x,1,0)
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x);
Co zrobić jeśli chcemy aby a = 2?
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,2);
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,2); // ⇒ Parabola(x,2,0)
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,2);
A jeśli ma być b = 5?
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
A jeśli chcemy aby a = 1 i b = 5?
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x,5);
Czy można tak?
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
y = Parabola(x, ,5);
A może tak?
Wartości domyślne
Pliki nagłówkowe
{
return a∗x∗x+b;
}
int main()
{
float y, x=5;
}
Jeśli chcemy zmodyfikować wartość jednego z parametrów domyślnych, to musimy podać wartości wszystkich parametrów, aż do miejsca, na którym występuje zmodyfikowana wartość.
Wartości domyślne
Pliki nagłówkowe
void PokazOdleglosc( float t, float a = 9.81, const char∗ Jedn = ”m” )
.....
Wartości domyślne
Pliki nagłówkowe
{
cout << a∗pow(t,2)/2 << Jedn << endl;
}
....
Wartości domyślne
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1, 9.81, ”cm”);
}
...
Wartości domyślne
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1, ”cm”);
}
Czy można to skrócić korzystając z tego, że zadeklarowane wartości domyślne
dla a i Jedn są różne od Jedn?
..
Wartości domyślne
Pliki nagłówkowe
{
}
int main( )
{
h
h
hh
(
(
hh
((
hh
(
((
h
hh
(
(
((
h
(
(
PokazOdleglosc(1,
”cm”);
h
h
(
(
h
h
hh
(
(
((
h
hh
(
(
h
(
(
}
Tego typu wywołanie jest niepoprawne. To że parametry są różnego typu nie
ma żadnego znaczenia.
.
Wartości domyślne
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1, 9.81, ”cm”);
}
Jedyną poprawną formą jest wypisanie wszystkich wartości parametrów pośrednich, niezależnie od tego czy są one zgodne z wartościami domyślnymi, czy też
nie.
Wartości domyślne
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1);
}
Powróćmy do wywołania funkcji korzystającego z wartości domyślnych
Wartości domyślne
Pliki nagłówkowe
Zapowiedź definicji funkcji
int main( )
{
PokazOdleglosc(1);
}
{
}
....
Wartości domyślne
Pliki nagłówkowe
int main( )
{
PokazOdleglosc(1);
}
{
}
...
Wartości domyślne
Pliki nagłówkowe
int main( )
{
PokazOdleglosc(1);
}
{
}
Wywołanie funkcji przed jej definicją jest możliwe wtedy i tylko wtedy, gdy
wcześniej wystąpi nagłówek zapowiedzi definicji.
..
Wartości domyślne
Pliki nagłówkowe
void PokazOdleglosc( float t, float a = 9.81, const char∗ Jedn = ”m” );
int main( )
{
PokazOdleglosc(1);
}
{
}
To też nie jest dobrze.
.
Wartości domyślne
Pliki nagłówkowe
int main( )
{
PokazOdleglosc(1);
}
P
³
³
P³
P³
void PokazOdleglosc( float t, float a =P
9.81
, const char∗ Jedn =³
”m”
³
P
P)
{
}
Jeżeli w jednostce translacyjnej występuje zapowiedź definicji z parametrami
domyślnymi oraz sama definicja, to wartości tych parametrów mogą być zadeklarowane tylko raz w nagłówku jej zapowiedzi.
Wartości domyślne
Pliki nagłówkowe
int main( )
{
PokazOdleglosc(1);
}
void PokazOdleglosc( float t, float a, const char∗ Jedn )
{
}
Teraz jest już dobrze.
Wartości domyślne
Pliki nagłówkowe
int main( )
{
PokazOdleglosc(1);
}
{
}
........
Wartości domyślne
Pliki nagłówkowe
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
modul.cpp
{
}
.......
Wartości domyślne
Pliki nagłówkowe
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
modul.cpp
{
}
Jeżeli występuje więcej jednostek translacyjnych, to ta sama funkcja może być różnie traktowana w każdej z nich.
......
Wartości domyślne
Pliki nagłówkowe
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
modul.cpp
void PokazOdleglosc( float t, float a = 981, const char∗ Jedn = ”cm” )
{
}
Wartości parametrów domyślnych mogą być różne w każdej z nich lub
w ogóle mogą nie występować. To nie jest jednak dobre rozwiązanie.
.....
Wartości domyślne
Pliki nagłówkowe
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
modul.cpp
{
}
Wartości parametrów domyślnych mogą być różne w każdej z nich lub
w ogóle mogą nie występować. To nie jest jednak dobre rozwiązanie.
....
Wartości domyślne
Pliki nagłówkowe
modul.hpp
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
modul.cpp
{
}
Lepszym rozwiązaniem jest wydzielenie pliku nagłówkowe.
...
Wartości domyślne
Pliki nagłówkowe
modul.hpp
prog.cpp
#include ”modul.hpp”
int main( )
{
PokazOdleglosc(1);
}
modul.cpp
{
}
..
Wartości domyślne
Pliki nagłówkowe
modul.hpp
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
{
}
modul.cpp
Dodanie pliku nagłówkowego zapobiega niejednoznacznemu traktowania
parametrów domyślnych.
.
Wartości domyślne
Pliki nagłówkowe
modul.hpp
prog.cpp
int main( )
{
PokazOdleglosc(1);
}
{
}
modul.cpp
Nie jest to jednak jedyny niezbędny plik nagłówkowy.
.
Wartości domyślne
Pliki nagłówkowe
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1);
}
Wróćmy do konstrukcji jednomodułowej.
..
Wartości domyślne
Pliki nagłówkowe
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1);
}
Aby było wszystko dobrze w jednostce translacyjnej muszą być dołączone pliki nagłówkowe zawierające definicje lub zapowiedzi definicji wykorzystywanych
funkcji i struktur danych.
.
Wartości domyślne
Pliki nagłówkowe
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1);
}
W tym przypadku dotyczy to obiektu cout, manipulatora endl oraz funkcji
pow. A jak to wyglądało by w C?
Wartości domyślne
Pliki nagłówkowe
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1);
}
W tym przypadku dotyczy to obiektu cout, manipulatora endl oraz funkcji
pow. A jak to wyglądało by w C?
Wartości domyślne
Pliki nagłówkowe
Pliki nagłówkowe dla programu w C
{
printf(”%f%s\n”, a∗pow(t,2)/2, Jedn );
}
int main( )
{
PokazOdleglosc(1);
}
....
Wartości domyślne
Pliki nagłówkowe
{
}
int main( )
{
PokazOdleglosc(1);
}
Pliki nagłówkowe potrzebne są dla funkcji printf oraz pow.
...
Wartości domyślne
Pliki nagłówkowe
#include <stdio.h>
#include <math.h>
{
}
int main( )
{
PokazOdleglosc(1);
}
..
Wartości domyślne
Pliki nagłówkowe
#include <stdio.h>
#include <math.h>
{
}
int main( )
{
PokazOdleglosc(1);
}
W stdio.h znajduje się prototyp funkcji printf.
.
Wartości domyślne
Pliki nagłówkowe
#include <stdio.h>
#include <math.h>
{
}
int main( )
{
PokazOdleglosc(1);
}
Natomiast w math.h znajduje się prototyp funkcji pow.
Wartości domyślne
Pliki nagłówkowe
#include <stdio.h>
#include <math.h>
{
}
int main( )
{
PokazOdleglosc(1);
}
A jak to będzie w C++?
Wartości domyślne
Pliki nagłówkowe
Pliki nagłówkowe dla programu w C++
{
}
int main( )
{
PokazOdleglosc(1);
}
..
Wartości domyślne
Pliki nagłówkowe
#include <iostream>
#include <cmath>
using namespace std;
{
}
int main( )
{
PokazOdleglosc(1);
}
.
Wartości domyślne
Pliki nagłówkowe
#include <iostream>
#include <cmath>
{
}
int main( )
{
PokazOdleglosc(1);
}
W istream znajduje się zapowiedź deklaracji obiektu cout i prototyp manipulatora endl.
Wartości domyślne
Pliki nagłówkowe
#include <iostream>
#include <cmath>
{
}
int main( )
{
PokazOdleglosc(1);
}
Natomiast w cmath znajduje prototyp funkcji pow.
Wartości domyślne
Pliki nagłówkowe
Odpowiedniość plików nagłówkowych dla C i C++
<math.h>
<stdio.h>
<ctype.h>
<stdlib.h>
<string.h>
Wartości domyślne
Pliki nagłówkowe
<math.h>
−→
<cmath>
<stdio.h>
<ctype.h>
<stdlib.h>
<string.h>
Wartości domyślne
Pliki nagłówkowe
<math.h>
−→
<cmath>
<stdio.h>
−→
<cstdio>
<ctype.h>
<stdlib.h>
<string.h>
Wartości domyślne
Pliki nagłówkowe
<math.h>
−→
<cmath>
<stdio.h>
−→
<cstdio>
<ctype.h>
−→
<cctype>
<stdlib.h>
<string.h>
Wartości domyślne
Pliki nagłówkowe
<math.h>
−→
<cmath>
<stdio.h>
−→
<cstdio>
<ctype.h>
−→
<cctype>
<stdlib.h>
−→
<cstdlib>
<string.h>
Wartości domyślne
Pliki nagłówkowe
<math.h>
−→
<cmath>
<stdio.h>
−→
<cstdio>
<ctype.h>
−→
<cctype>
<stdlib.h>
−→
<cstdlib>
<string.h>
−→
<cstring>
Wartości domyślne
Pliki nagłówkowe
Domyślne wartości parametrów dla metod
class LZespolona {
public :
float re, im;
void Zmien(float r, float i) { re = r; im = im; }
};
int main( )
{
LZespolona
Z.re = 2.1;
Z;
Z.im = 0;
}
Wartości domyślne
Pliki nagłówkowe
class LZespolona {
public :
float re, im;
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1, 0);
}
Wartości domyślne
Pliki nagłówkowe
class LZespolona {
public :
float re, im;
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
Wartości domyślne
Pliki nagłówkowe
class LZespolona {
public :
float re, im;
void Zmien(float r, float i = 0) { re = r; im = im; }
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
Wartości domyślne
Pliki nagłówkowe
Definiowanie metody poza ciałem klasy
class LZespolona {
public :
float re, im;
void Zmien(float r, float i = 0);
};
void LZespolona::Zmien(float r, float i)
{
re = r; im = i;
}
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
Nieszczęsne słowo: overload
Przeładowanie czy przeciążenie?
Przeładowanie — Jak to rozumieć?
Przeładowanie — (1) do istniejącego ładunku dodajemy nowy przekraczając dopuszczalną pojemność.
Przeładowanie — (2) istniejącą zawartość wyładowujemy i na jej
miejsce wprowadzamy nowy ładunek.
Przeciążenie — A to jak rozumić?
Przeciążenie — (1) do istniejącego ładunku dodajemy nowy przekraczając dopuszczalny ciężar.
Przeciążenie — (2) do istniejących obowiązków (zadań, powinności itd.) dodajemy nowe przekraczając nowinalny zakres.
Przeładowanie — (1) do istniejącego ładunku dodajemy nowy przekraczając dopuszczalną pojemność.
Przeładowanie — (2) istniejącą zawartość wyładowujemy i na jej
miejsce wprowadzamy nowy ładunek.
Przeciążenie — (1) do istniejącego ładunku dodajemy nowy przekraczając dopuszczalny ciężar.
Przeciążenie — (2) do istniejących obowiązków (zadań, powinności itd.) dodajemy nowe przekraczając nowinalny zakres.
Przeciążanie funkcji
Przeciążanie funkcji (ang. function overloading) pozwala na definiowanie funkcji o tych samych nazwach, które różnią się ilością lub typami
parametrów. Mogą (lecz nie muszą) zwracać wartości różnego typu.
Mechanizm ten pozwala stosować funkcję realizującej ten sam typ operacji w różnych kontekstach.
Przykład:
void Wyswietl( float Liczba )
{
cout << ”Liczba: ” << Liczba
}
<< endl;
Przykład:
{
}
<< endl;
void Wyswietl( const char ∗ Napis )
{
cout << ”Napis: \”” << Liczba << ”\””
}
<< endl;
Przykład:
{
}
<< endl;
{
}
<< endl;
void main( )
{
Wyswietl(123.14);
Wyswietl(”Jak dobrze wstać skoro świt.”);
}
Przykład:
{
}
<< endl;
{
}
<< endl;
void main( )
{
Wyswietl(123.14);
}
Przykład:
{
}
<< endl;
{
}
<< endl;
void main( )
{
Wyswietl(123.14);
}
Przeciążanie zamiast wartości domyślnych
void PokazOdleglosc( float t, float a= 9.81, const char∗ Jedn = ”m” )
{
}
........
{
}
void PokazOdleglosc( float t )
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
.......
{
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
Te dwie definicje funkcji prowadzą do niejednoznaczności. Dlaczego?
......
{
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
Powstałą niejednoznaczność usuwamy rezygnując z wartości domyślnej dla parametru a.
.....
void PokazOdleglosc( float t, float a, const char∗ Jedn = ”m” )
{
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
....
{
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
...
{
}
void PokazOdleglosc( float t, float a )
{
cout << a∗pow(t,2)/2 << ”m” << endl;
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
..
{
}
{
cout << a∗pow(t,2)/2 << ”m” << endl;
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
.
{
}
{
cout << a∗pow(t,2)/2 << ”m” << endl;
}
{
cout << 9.81∗pow(t,2)/2 << ”m”
}
<< endl;
{
}
{
cout << a∗pow(t,2)/2 << ”m” << endl;
}
{
cout << 9.81∗pow(t,2)/2 << ”m” << endl;
}
Przeciążanie zamiast stosowania wartości domyślnych nie jest dobrym pomysłem. Powielając kod niechcący można również powielać błędy.
Wciąż o przeciążaniu
double ObliczDroge( float t, float a )
{
return a∗pow(t,2)/2;
}
float ObliczDroge( float t, float V )
{
return V∗t;
}
Czy to jest przeciążenie i dlaczego?
{
}
{
return V∗t;
}
Przeciążanie jest realizowane tylko i wyłącznie względem listy parametrów i modyfikatora const, ale do tego dojdziemy później.
{
}
{
return V∗t;
}
Przeciążanie jest realizowane tylko i wyłącznie względem listy parametrów i modyfikatora const, ale do tego dojdziemy później.
{
}
float ObliczDroge( double t, double V )
{
return V∗t;
}
Teraz to już jest przeciążenie.
{
}
{
return V∗t;
}
Niech będzie dane wywołanie:
ObliczDroge(1, 1.2);
Która z funkcji będzie wywołana?
{
}
{
return V∗t;
}
Niech będzie dane wywołanie:
ObliczDroge(1, 1);
A teraz która z nich zostanie uruchomiona?
Przeciążenie metody
class LZespolona {
public :
float re, im;
void Zmien(float r, float i = 0) { re = r; im = im; }
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
class LZespolona {
public :
float re, im;
void Zmien(float r) { re = r; }
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
class LZespolona {
public :
float re, im;
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
class LZespolona {
public :
float re, im;
};
int main( )
{
LZespolona
Z;
Z.Zmien(2.1);
}
Przeciążenie operatorów
class LZespolona {
public :
float re, im;
...
};
LZespolona operator ∗ (LZespolona const &Z1, LZespolona const &Z2)
{ ... }
int main( )
{
LZespolona Wynik, Z1, Z2;
Wynik = Z1 * Z2;
}
class LZespolona {
public :
float re, im;
...
};
{ ... }
LZespolona operator ∗ (LZespolona const &Z1, float L)
{ ... }
int main( )
{
Wynik = Z1 * Z2 * 3;
}
class LZespolona {
public :
float re, im;
...
};
{ ... }
{ ... }
LZespolona operator ∗ (float L, LZespolona const &Z2)
{ ... }
int main( )
{
Wynik = 10.6 * Z1 * Z2* 3;
}
class LZespolona {
public :
float re, im;
LZespolona operator ∗ (LZespolona const &Z2) {
...
};
{ ... }
{ ... }
int main( )
{
Wynik = 10.6 * Z1 * Z2* 3;
}
}
class LZespolona {
public :
float re, im;
LZespolona operator ∗ (LZespolona const &Z2) const {
LZespolona operator ∗ (float L) const { . . . }
};
{ ... }
int main( )
{
Wynik = 10.6 * Z1 * Z2* 3;
}
...
}
To już koniec :(.

Wartosci domyslne i przeciazenia

Transkrypt

Podobne dokumenty

Reprezentacja liczb typu float

postulaty - Pike.org.pl

Nie ma ryzyka przeciążenia - SGB

Agenda spotkania 1. System zasilania EPSITRON

Lista zadań z ćwiczeń dla II IM z Podstaw