1 / 18

C++ Bjarne Stroustrup AT&T Bell-Laboratories

C++ Bjarne Stroustrup AT&T Bell-Laboratories. Historia 1980 - dodanie do C klas itp., jako punkt wyjścia przyjęto język Simula 67 (C z klasami) 1983/84 - powstanie C++ 1989 C++ wesja 2 (CFront 2.0, m.in. wielodziedziczenie) 1998 - Standard C++ (ISO/IEC 14882:1998).

bevan
Download Presentation

C++ Bjarne Stroustrup AT&T Bell-Laboratories

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. C++Bjarne StroustrupAT&T Bell-Laboratories • Historia • 1980 - dodanie do C klas itp., jako punkt wyjścia przyjęto język Simula 67 (C z klasami) • 1983/84 - powstanie C++ • 1989 C++ wesja 2 (CFront 2.0, m.in. wielodziedziczenie) • 1998 - Standard C++ (ISO/IEC 14882:1998). • 2003 - tech. korekty (ISO/IEC 14882:2003) • Zalety • Bazuje na bardzo popularnym C • efektywność połączona z obiektowością • możliwość tworzenia dużych systemów ułatwiona przez obiektowość • duża przenaszalność • ciągły rozwój • Wady • połączenie mechanizmów niskopoziomowych (z C) z wysokopoziomowymi mechanizmami obiektowymi - w C++ trudno programować dobrze • C++ zawiera prawie wszystkie znane mechanizmy obiektowe, a także połączenie tych mechanizmów z innymi, np. przeciążaniem funkcji

  2. Literatura • Język C++; Bjarne Stroustrup; WNT 2000; wyd. 5te i zmienione, • Język C++, ćwiczenia i rozwiązania; David Vandevoorde; WNT 2001, • The C++ Standard: Incorporating Technical Corrigendum No. 1, British Standards Institute782 pages, 2nd ed.,19 December 2003, • Podstawy języka C++; Stanley B. Lippman, Josee Lajoie; WNT 2001, • Podstawy języka C++, ćwiczenia i rozwiązania; Clovis L. Tondo; WNT 2001, • C++ Biblioteka standardowa, podręcznik programisty; Nicolai M. Josuttis; Helion 2003, • Projektowanie i rozwój języka C++, Bjarne Stroustrup, WNT 1996, • C++ zadania i odpowiedzi, Tony L. Hansen, WNT 1994, • Internet (draft proposed International Standard for Information Systems – Programming language C++, X3J16/96-0225, 2 XII 1996; 699 stron w tym 370 język, 329 biblioteki).

  3. Komentarze • /* wielowierszowy */ • // jednowierszowy • Deklaracje zmiennych • int x; // zmienna x typu integer • int y = 3; // zmienna y z określoną wartością początkową 3 • int z = y; // zmienna z określoną wartością pocz. y (czyli 3) • char * p; // zmienna p typu wskaźnik do znaku • T y; // zmienna y typu T • // T może być typem pierwotnym, klasą, strukturą • // lub unią • float tab [100]; // 100-elementowa tablica liczb rzeczywistych • int* tablica; // zapewne tablica liczb całkowitych • // rozmiar zostanie określony przez new • char ** str; // zapewne tablica wskaźników do znaków (czyli // napisów), rozmiar zostanie określony przez new • int (*arr) [10]; // wskaźnik do 10-elementowej tablicy liczb • int p[ ] = {4, 7, 8}; // 3-elementowa tablica zawierająca liczby 4, 7, 8 • Uwaga: nazwa tablicy jest utożsamiana ze stałym wskaźnikiem do pierwszego elementu tablicy. Elementy tablicy są zawsze indeksowane od 0. • int tab1 [100 ];jestprawie równoważneint * tab2; • tab1 [10 ] = 123; *(tab2 + 10) = 123; • *(tab1 + 10) = 123;tab2 [10 ] = 123; • a nawet • 10[tab1] = 123; 10[tab1] = 123; • ALE tab1 jest zainicjowane a tab2 NIE i po lewej jest 100-elementowa tablica, a po prawej nie ma jeszcze żadnej tablicy!!!

  4. Stałe (tylko C++) • const int x = 145; // nie można zmienić wartości x • const int *p; // nie można zmien. liczb wsk. przez p • const int V[ ] = {1, 2, 3, 4}; // nie można zmienić eltów tablicy V • const char * napis = “abcdef’; • char * const nap = “abcdef”; • const char* const nap3 = "abcdef"; • Specyfikacja const stwierdza, że nie można zmienić obiektu w ten • sposób zadeklarowanego. • V [ 3 ] = 10; // nielegalne • V = new int; // ok • napis [ 3 ] = ‘0’; // nielegalne • napis = “xyz”; // ok • nap [ 3 ] = ‘0’; // ok • nap = “xyz”; // nielegalne • Często używa się deklaracji const dla parametru funkcji aby podkreślić, • że funkcja tego parametru nie może zmienić (read only). • char * strcpy (char * p, const char * q); // *q nie może być zmieniane • Typy • (Niektóre) typy pierwotne: • char, short, int, long, float, double • Typy wyprowadzane (derived types): • * wskaźnik • & referencja • [ ] tablica • ( ) funkcja • Typy wyliczeniowe: • enum kolor { czerowny, bialy, czarny, zielony }; • // wprowadza już nazwę typu - kolor

  5. Konwersja typów: (stare) (char *) w float (29) (nowe) static_cast<float>(3) typ void “pusty“ typ • Wyrażenia • Instrukcja przypisania jest wyrażeniem (z efektami ubocznymi). • x = 23; • x++ wartością wyrażenia jest x • po wykonaniu wyrażenia x ma wartość zwiększoną o 1 • ++x wartością wyrażenia jest x+1 • po wykonaniu wyrażenia x ma wartość zwiększoną o 1 • x----x podobnie • x += w; // x = x + w; • Zamiast + może wystąpić inny operator, np. *, - • && koniunkcja || alternatywa • ! negacja • == porównanie != różne • int *p; int x; • *p obiekt wskazywany przez p • &x adres obiektu x; użycie: p = &x; • Uwaga na wskaźniki: • char *p = new char[strlen(src+1)]; • strcpy(src, p); • // Błędny fragment programu (ale kompilujący się bez • // ostrzeżeń) zwn złe położenie czerwonego nawiasu.

  6. Referencje • T - typ, T& - typ “referencja do T” • Referencja jest inną nazwą obiektu (aliasem). • int i = 1; • int& r = i; // wartością i oraz r jest ten sam obiekt (liczba) • // zmienna typu referencyjnego musi być zainicjowana • r = 5; // teraz także i == 5 • Referencje są używane przy parametrach funkcji do przekazywania • parametrów przez referencję (tak, jak przez zmienną w Pascalu). • Nie może być wskaźników do referencji (ani tablic referencji). Ale referencja do wskaźnika jest poprawna. • Referencja to nie jest wskaźnik !!! • Przykład: • Funkcja zamieniająca wartości dwóch zmiennych. • (1) za pomocą wskaźników • void swap (int * a, int * b) • { • int temp; • temp = *a; *a = *b; *b = temp; • } • wywołanie: swap (&x, &y ); // tu & oznacza adres • (2) za pomocą referencji • swap (int& a, int& b) // parametrem aktualnym musi być zmienna • { • int temp; • temp = a; a = b; b = temp; • } • wywołanie: swap (x, y); • Referencji używamy najczęściej wtedy, gdy jako parametr funkcji • chcemy przekazać obiekt, a nie jego kopię.

  7. Instrukcje • Wyrażenie zakończone ; jest instrukcją. np. x++; • { lista instrukcji } • if (wyrażenie) instrukcja • if (wyrażenie) instrukcja1 else instrukcja2 • if (x < 0) • x++; • while (wyrażenie) instrukcja • do instrukcja while (wyrażenie); • while (i < n && tab [ i ] != x) // n - rozmiar tablicy • i++; • do x = x - y; while (x > y); • { char *nap1 = ‘123456789’; • char nap2 [100] ; • char * p, * q; • p = nap1; q = nap2; • while ( *p != 0) * q ++ = *p ++; • } • for (instr_start wyr_końcowe; wyr) instrukcja2; • instr_start; • while (wyr_końcowe) • { • instrukcja2; • wyr; • } • for (i=0; i < n ; i++) tab [ i ] = 100;

  8. break; // przerywa wykonanie pętli lub instrukcji switch • return wyrażenie; // powrót z funkcji • switch (wyr) • { • case const1: instr1; • instr2; • ..... • break; // powoduje wyjście z instrukcji switch • case const2: instr1; • ...... • default: instr1; • instr2; • .... • } • Funkcje • float pow (float x, int n) • { • float y = 0; • if (n < 0) • error (“ ujemny wykładnik”); • else • switch ( n ) • { • case 0: y = 1; break; • case 1: y = x; break; • dafault: y = x * pow ( x, n-1 ); • } • return(y); • }

  9. void main ( ) • { • ...... // główna funkcja • } • Przekazywanie parametrów • przez wartość tylko (normalny sposób w C) ALE • może być typ referencyjny (tylko C++) • void zamien (int &x, int &y) • // zamienia wartości zmiennych x i y; • { • int pom; • pom = x; • x = y; • y = pom; • } • void main ( ) • { • int a = 13; • int b = 3445; • zamien (a, b); • ... • }

  10. Deklaracja funkcji: określa jej nagłówek (nazwę, typ, liczbę i typy • argumentów) • int zamien (int &x, int &y); • Definicja funkcji: definiuje treść funkcji • int zamien (int &x, int &y) • { .... } • Każda funkcja musi być zadeklarowana przed użyciem. • Argumenty domyślne (tylko C++) • void f (int i, float x = 1.0); // argumenty domyślne muszą • być na końcu • możliwe wywołania: • f (2, 3.0); • f ( 5); • Argument domyślny jest obliczany w momencie wywołania funkcji. • Funkcje wstawiane (inline) (tylko C++) • inline int max (int x, int y) • { • return x > y ? x : y; • } • Przeciążanie funkcji (tylko C++) • Deklaracja kilku funkcji o tej samej nazwie, lecz o różnej liczbie lub • różnych typach argumentów. • void print (char * s); // będzie wykonana dla wywołania print (“aaa”) • void print (int n); // będzie wykonana dla wywołania print (10)

  11. Typy - c.d. (w C++) • Struktury i unie • struct para { • char * nazwa; • int wartość; • }; • para p, kolor k; • struct entry { • char * nazwa; • char typ; // ‘n’ - dla napisu, ‘l’ - dla liczby • union { • char * wartość_napis; // używana, gdy typ == ‘n’ • int wartość_liczba; // używana, gdy typ == ‘l’ • }; • entry en; • ... • if (en.typ == ‘n’) • cout << en.wartość_napis • else • cout << en.wartość.liczba; • Tworzenie i niszczenie obiektów • char * s = new char [10]; // napis 9-cio znakowy • int * wsk = new int; • wsk = new int; // wskaźnik do nowego obiektu - liczby • delete wsk; // zwalnia pamięć wskazywaną przez wsk • delete[] s; // zwalnia 10-cio elementową tablicę s

  12. Wejście/wyjście (strumienie) • (tylko C++) • operatory << >> • wynikiem zastosowania tych operatorów jest strumień. • standardowe strumienie cin, cout, cerr • cout << “Podaj wartości dla i oraz j: “; • cin >> i >> j; • cout << “Sumą i oraz j jest “ << i + j << “\n”; • Są też funkcje: • get(c) f.get(c) • put (c) f.put (c) • eof () f.eof () • cout, cin, f - to są obiekty klasy iostream. • Klasa fstream obsługuje pliki dyskowe (jest podklasą klasy iostream). • Obiekty klas ifstream i ofstream są plikami otwieranymi domyślnie do czytania i pisania. • ifstream input (“dane.txt”); // tworzy strumień związany • // z plikiem “dane.txt” • // otwartym do czytania • ofstream output (“wynik.txt”); // do pisania

  13. Struktura programu i widoczność nazw • Program jest ciągiem deklaracji typów, stałych, zmiennych i • funkcji. • Program może być wieloplikowy. Plik pełni rolę czegoś • w rodzaju modułu (grupuje deklaracje typów, zmiennych i funkcji • na nich działających). • Nie ma zagnieżdżania funkcji. • Wykonanie programu zaczyna się od wykonania funkcji main. • Wszystkie typy i funkcje są nazwami zewnętrznymi. • Nazwy globalne: zadeklarowane na poziomie pliku. • Każda nazwa globalna jest widoczna od momentu jej • zadeklarowania do końca pliku. • Nazwa zmiennej lokalnej w funkcji jest widoczna od momentu jej • zadeklarowania do końca funkcji. • Nazwa zmiennej lokalnej w bloku jest widoczna od momentu jej • zadeklarowania do końca bloku. • Deklaracja funkcji: • int f (int x); // tylko nagłówek • extern char * g ( ); // • Definicja funkcji: • int f (int x) • { • ...... // treść funkcji • } • Plik nagłówkowy: zawiera deklaracje, które mają być wspólne dla • wielu plików. • #include <fstream> // włączenie standardowego pliku nagłówkowego • #include "mojplik.h" // włączenie własnego pliku nagłówkowego

  14. Liczymy liczbę wystąpień słów kluczowych na pliku • #include <fstream> • char *słowa [ ] = • { “begin”, “end”, “if”, “while”, “record” }; • const n = 5; • int licznik [ n ]; • char * daj_słowo ( ifstream str); // deklaracja funkcji • // daje następne słowo ze strumienia; NULL - jeśli nie ma już słowa • void wypisz_wynik ( ) • // wypisuje wynik - słowa i liczbę wystąpień • { • for ( int i = 0; i < n; i++) • cout << słowa [ i ] << “\t” << licznik [ i ] << “\n”; • } • void policz (char * slowo ) • // dla danego słowa zwiększa licznik o 1 jeśli jest to sł. kluczowe • { • int i = 0; • while ( i < n && strcmp (slowo, slowa [ i ]) != 0) i++; • if ( i < n ) • licznik [ i ] ++; • } • void main ( ) • { • char * s; • fstream str (“ ... “); // .związanie strumienia str z plikiem • while ((s = daj_slowo( str )) != NULL) • policz (s ); • wypisz_wynik (); • }

  15. Liczymy, ile jest różnych słów na pliku. Przez słowo rozumiemy ciąg znaków nie zawierających “białych” znaków. W wyniku wypisujemy słowa i liczbę ich wystapień w kolejności alfabetycznej. Plik o nazwie czyt.h #include <fstream> // funkcja czyta słowo (ciąg znaków różnych "białych" znaków extern char * daj_slowo (ifstream & f); Plik o nazwie tree.h // typy danych określające strukturę do przechowywania słów #include <fstream> struct wezel { char * slowo; int ile; wezel* lewy; // wskaźnik do lewego poddrzewa wezel* prawy; // wskaźnik do prawego poddrzewa }; typedef wezel* drzewo; extern void wstaw(char * s, drzewo & D); // wstawia słowo do drzewa extern void wypisz(drzewo D, ofstream & wy); // obchodzi drzewo Plik o nazwie slowa.h #include <fstream> // <> dla bibliotek standardowych #include "tree.h" // " " dla bibliotek prywatnych extern void pisz_wyniki( ofstream & wynik); // wypisuje wynik extern void licz (ifstream & dane); // czyta i liczy słowa

  16. Plik zawierający treść funkcji czytającej słowo #include <fstream.h> #include <string.h> #include "czyt.h" static const MAX = 50; // maksymalna długość słowa static char buf[MAX]; // bufor do przechowywania słowa static inline int BIALE (char c) { return (c == ' ' || c == '\t' || c == '\n'); } // funkcja zwraca wskaźnik do przeczytanego słowa lub NULL, // jeśli słowa już nie było char * daj_slowo (istream & f) { int i; char c; char * s; c = ‘ ‘; while (!f.get(c).eof() && BIALE (c)); // pomijanie spacji if (BIALE (c) || f.eof () ) return(NULL); // nie ma kolejnego slowa // czytaj słowo do bufora i = 0; do buf [i++] = c; while ( !f.get(c).eof () && (! BIALE (c)) && (i < MAX-1)); // zwracamy przeczytane słowo buf[i] = '\0'; s = new char [i+1]; strcpy (s, buf); return(s); }

  17. Plik zawierający operacje na drzewie BST • #include <fstream.h> • #include "tree.h" • // funkcja wstawia słowo s do drzewa D, zwiększa licznik • void wstaw(char * s, drzewo & D) // parametr przekazany przez ref. • { • int b; • if (D == NULL) { // nie bylo jeszcze tego słowa • D = new wezel; D -> slowo = s; D -> ile = 1; • D -> lewy = D -> prawy = NULL; • } • else { • b = strcmp (D -> slowo, s); • if (b > 0) // idziemy w lewo • wstaw(s, D -> lewy); • else if (b < 0) // idziemy w prawo • wstaw(s, D -> prawy); • else • { • (D -> ile)++; • return; • } • } • } // koniec funkcji • // wypisanie słów z drzewa D na plik wy • void wypisz(drzewo D, ofstream & wy) • { • if (D == NULL) return; • wypisz (D -> lewy, wy); • wy << D -> slowo << " " << D ->ile << "\n"; • wypisz (D -> prawy, wy); • }

  18. Plik zawierający treści funkcji liczących liczbę słów #include <fstream> #include "czyt.h" #include "tree.h" #include “slowa.h” static drzewo Slowa = NULL; // drzewo slow // funkcja wypisuje częstości wystśpień słów w porządku alfabetycznym // na plik wy void pisz_wyniki( ofstream & wynik) { wypisz(Slowa, wynik); } // funkcja liczy częstotliwość występowania słów na pliku we */ void licz (ifstream & dane) { char * s; while ((s = daj_slowo(dane)) != NULL) wstaw (s, Slowa); } • Program główny • #include <fstream> • #include “slowa.h” • void main ( int argc, char * argv [ ] ) • { // utworzenie obiektów dane i wynik • ifstream dane (argv [1]); • ofstream wynik (argv[2]); • licz (dane ) ; pisz_wyniki (wynik); • }

More Related