MouseListener
Warunek wielokrotnego wyboru switch ... case
Warunek switch ... case został wprowadzony, w celu poprawienia czytelności kodu. Nie umożliwia on bowiem bardziej zaawansowanych warunków, niż oferuje nam to wcześniej omawiany warunek typu if ... else. Można nawet powiedzieć, że warunek switch ... case ma dużo mniejsze możliwości, od if ... else. Po co więc nam on? Otóż są sytuacje, w których warto skorzystać warunku switch ... case i dlatego zostanie on omówiony. Przyjrzyjmy się najpierw składni.
switch(zmienna)
{
case wartosc1:
//tu instrukcje zostaną wykonane jeśli (zmienna==wartosc1)
break;//koniec warunku; wychodzi z warunku switch
case wartosc2:
//tu instrukcje zostaną wykonane jeśli (zmienna==wartosc2)
break;//koniec warunku; wychodzi z warunku switch
//tu mogą być kolejne case ...
default://instrukcja warunkowa switch wykonuje ten kod
//wtedy i tylko wtedy, gdy nie został spełniony
//żaden inny wyżej wymieniony warunek
break;//wychodzi z warunku switch;
}
Warto w tym miejscu wymienić kilka przykładów, gdzie warto stosować warunek typu switch...case - są to głównie listy wyboru, gdzie na podstawie np. naciśniętego klawisza, wybieramy dalszy przebieg programu. Można również porównywać napis wprowadzony przez użytkownika i gdy któryś z nich będzie taki sam, jak w warunku switch...case, to wykona się określony kod.
O czym należy pamiętać korzystając ze switch ... case
Zostały jeszcze dwie ważne sprawy, które powinieneś wiedzieć jako przyszły programista. Sprawa pierwsza to: w warunku switch...case nie można deklarować zmiennych. Jeśli potrzebujesz koniecznie zmienną tymczasową, to musisz ją zadeklarować przed warunkiem switch...case. Druga sprawa: jeśli zapomnisz słowa kluczowego break;, każdy kolejny warunek się wykona w switch'u (aż do napotkania słówka break;).
Praktyczny przykład wykorzystania switch ... case
Poniżej zamieszczam przykład prezentujący działanie switch...case.
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
float a;
float b;
cout<<"Podaj pierwsza liczbe: ";
cin>>a;
cout<<"Podaj druga liczbe: ";
cin>>b;
cout<<"liczba a: "<<a<<endl;
cout<<"liczba b: "<<b<<endl;
cout<<"Menu wyboru:"<<endl;
cout<<"[1] Oblicz: a+b"<<endl;
cout<<"[2] Oblicz: a-b"<<endl;
cout<<"[3] Oblicz: a*b"<<endl;
cout<<"[4] Oblicz: a/b"<<endl;
cout<<"Wpisz numer: ";
int wybor;
cin>>wybor;
cout<<endl<<"Wpisales numer: "<<wybor<<endl;
switch(wybor)
{
case 1:
cout<<"Opcja "<<wybor<<" wynik dodawania a+b="<<a+b<<endl;
break;
case 2:
cout<<"Opcja "<<wybor<<" wynik odejmowania a-b="<<a-b<<endl;
break;
case 3:
cout<<"Opcja "<<wybor<<" wynik mnozenia a*b="<<a*b<<endl;
break;
case 4:
cout<<"Opcja "<<wybor<<" wynik dzielenia a/b="<<a/b<<endl;
break;
default:
cout<<"Opcja "<<wybor<<" taka opcja nie istnieje!"<<endl;
break;
}
getch();
return(0);
}
Pętla for
Składnia pętli for(...)
Pętlę for można podzielić na cztery części:
Inicjacja początkowych wartości zmiennych (A)
Ustalenie warunku kończącego pętlę (B)
Zwiększenie (zmniejszenie) licznika pętli (C)
Powtarzany blok instrukcji (D);
Prosty przykład pętli:
for(int i=1;i<=10;i++)
{
//Powtarzany blok instrukcji
}
//lub
for(int i=1;i<=10;i++) jedna_powtarzana_instrukcja;
Zapis int i=1 jest to inicjacja początkowej wartości zmiennej. Zapis ten oznacza, że tworzymy zmienną typu int, nazywamy ją i oraz nadajemy jej wartość początkową równą 1. Kolejną część pętli for stanowi warunek. W tym przypadku jest to i<=10 i oznacza tyle, że dopóki warunek jest prawdziwy, to ma wykonywać blok instrukcji. Trzecią częścią, bez której pętla for nie byłaby sobą to zwiększenie bądź zmniejszenie wartości zmiennej. W tym przypadku jest to zapis i++. Zmienna ta jest zwiększana za każdym razem po wykonaniu wszystkich instrukcji z bloku.
Pętla for(...) a jej użyteczność
Pętlę for używamy praktycznie zawsze, gdy znamy ilość danych, jaką mamy wczytać, wypisać lub zmienić. Jeśli chcemy policzyć średnią z określonej liczby liczb, wczytać określoną ilość danych z pliku lub wypisać określoną ilość danych na ekran, pętla for jest do tego po prostu idealna.
Analizujemy przykłady
Przeanalizuj teraz dokładnie działanie poniższych programów. Przepisz je i uruchom, a następnie wykonaj kilka eksperymentów modyfikując jego działanie. Eksperymenty są zalecane przy nauce programowania. Warto też wprowadzać celowo po jednym błędzie w kodzie, żeby zapoznawać się stopniowo z komunikatami, jakie zacznie nam pokazywać kompilator jeśli zapis będzie nieprawidłowy lub jak zacznie zachowywać się nasz program. Nie bój się eksperymentów, to one dają Ci doświadczenie!
Liczenie średniej ocen
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int ilosc;
float ocena;
float srednia;
cout<<"Podaj ilosc ocen: ";
cin>>ilosc;
srednia=0;
for(int i=1;i<=ilosc;i++)
{
cout<<"Podaj ocene nr "<<i<<": ";
cin>>ocena;
srednia+=ocena;
}
if(ilosc>0) srednia/=ilosc;
cout<<"Srednia ocen to: "<<srednia<<endl;
getch();
return(0);
}
Tabliczka mnożenia
#include <iostream>
#include <conio.h>
#include "console.ddt"
int main()
{
clrscr();
for(int k=1;k<=10;k++)
{
for(int i=1;i<=15;i++)
{
cout<<i<<"*"<<k<<"="<<i*k<<" ";
}
cout<<endl;
}
getch();
return(0);
}
Pętla while i do ... while
Wczytując dane często zdarza się również tak, że nie chcemy z góry określać ilości wczytywanych danych do programu. Decyzję o tym, czy dane będą dalej wprowadzane czy nie użytkownik ma podejmować w każdym kroku. Pętla for(...) już na pierwszy rzut oka byłaby niewygodna do tego celu.
Poznajemy pętlę do ... while(...);
W przypadku, gdy chcemy wczytać określone dane conajmniej jeden raz, wykorzystujemy do tego celu pętlę do ... while(...). Składnia tej pętli wygląda następująco:
do
{
//tu instrukcje które mają być powtarzane
}while(warunek);
Pętla ta wykona najpierw blok instrukcji zawarty między klamrami, a następnie sprawdzi czy warunek jest spełniony (prawdziwy) czy też nie. Pętla wykonuje się tak długo, dopóki warunek jest prawdziwy.
Liczymy średnią ocen jeszcze raz
Ręczne liczenie ilości ocen jest dość monotonnym zajęciem. Ponieważ chcemy tego uniknąć, napiszemy program, który wczytuje oceny dopóki nie napotka stopnia 0. Wiemy przecież, że nie istnieje ocena 0, więc dla programu będzie to znak, że nie mamy więcej ocen do wczytania i chcemy poznać średnią. Program taki będzie wyglądał następująco:
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int ilosc=0;
float srednia=0;
float ocena;
do
{
cout<<"Podaj ocene (0 konczy wprowadzanie): ";
cin>>ocena;
if(ocena>0)
{
srednia+=ocena;
ilosc+=1;
}
}while(ocena!=0);
if(ilosc>0) srednia/=ilosc;
cout<<"Wprowadziles "<<ilosc<<" ocen"<<endl;
cout<<"Srednia ocen to: "<<srednia<<endl;
getch();
return(0);
}
Pętla while (...)
Do tej pory poznaliśmy dwie pętle: for(...) i do ... while(...). Istnieje również trzecia pętla i jest nią pętla while(...). Składnia tej pętli wygląda następująco:
while(warunek)
{
//powtarzany blok instrukcji
}
Różnica jest subtelna pomiędzy pętlą do ... while(...), a aktualnie omawianą while (...). W pętli while(...) warunek jest sprawdzany zanim wykona się blok instrukcji. W konsekwencji, jeśli warunek nie będzie spełniony, to blok zawarty poniżej pętli while(...) nie wykona się ani razu. Blok jest powtarzany tak długo, jak długo jest spełniony warunek pętli while(...).
Zastosowanie pętli while (...)
Pętlę while(...) zazwyczaj używa się częściej niż pętlę do ... while(...). Prawdopodobnie jest to podyktowane faktem, że dobrym zwyczajem jest i tak inicjacja początkowa wszystkich niezbędnych zmiennych. Jeśli będziemy chcieli, żeby pętla wykonała się conajmniej jeden raz to ustawimy wartości początkowe zmiennych tak, aby warunek tej pętli był spełniony. Nie jest to jednak żadna reguła i nie należy przywiązywać do tego wagi. Wszędzie tam, gdzie możemy użyć pętli do ... while(...), możemy również użyć pętli while(...) i na odwrót. Oczywiście zamiana jednej pętli na drugą będzie się wiązała z dodatkowymi, zazwyczaj drobnymi zmianami w kodzie.
Polecenia continue; break;
Skoro poznaliśmy już wszystkie możliwe pętle, warto w tym miejscu wtrącić słowo o instrukcjach continue; i break;. Jeśli nadal masz problemy z posługiwaniem się pętlami, wróć do wcześniejszego materiału ponieważ ten rozdział zakłada już, że znasz dobrze zasady działania każdej pętli.
Słowo kluczowe continue;
Kompilator C++, jak w większości języków programowania umożliwia nam modyfikowanie w dość specyficzny sposób działanie pętli. Słowo kluczowe continue; użyte wewnątrz pętli powoduje przerwanie wykonywania bloku instrukcji i przechodzi do sprawdzenia warunku kończącego pętlę. Jeśli jest to pętla for(...), wykonuje się jeszcze inkrementacja (lub dekrementacja) zmiennej.
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int i=0;
do
{
cout<<"i="<<i<<endl;
if(i==0)
{
i+=1;
continue;
}
cout<<"koniec"<<endl;
}while(i==0);
for(i=0;i<5;i++)
{
cout<<"[for] i="<<i<<endl;
if(i>2) continue;
cout<<"[for]koniec"<<endl;
}
getch();
return(0);
}
Słowo kluczowe break;
Drugim słowem kluczowym, które modyfikuje działanie każdej pętli to break;. Użycie tego słowa wewnątrz pętli zmusi ją do natychmiastowego jej przerwania. Słowo kluczowe break; zatrzymuje pracę tylko jednej pętli. Oznacza to, że jeżeli zagnieździmy dwie pętle, to zostanie zatrzymana pętla ta, w której zostało słowo kluczowe break; użyte. Poniższy przykład ilustruje działanie tej instrukcji w praktyce.
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int j;
for(j=0;j<10;j++)
{
cout<<"Aktualne j to: "<<j<<endl;
for(int i=0;i<5;i++)
{
cout<<"[for] i="<<i<<endl;
if(i>2) break;
cout<<"[for]koniec"<<endl;
}
if(j>6) break;
}
getch();
return(0);
}
Wskazana powściągliwość
Zanim zaczniesz nagminnie używać tych poleceń, zastanów się lepiej jak można napisać kod unikając używania słów kluczowych continue; i break;. Praktycznie zawsze istnieje możliwość napisania pętli bez użycia wymienionych słów kluczowych. Używaj ich tylko w skrajnie uzasadnionych przypadkach czyli wtedy gdy naprawdę uważasz, że czytelniejszym rozwiązaniem będzie użycie jednego z wymienionych słów kluczowych, niż modyfikacja pewnej partii kodu.
Funkcje w C++
Ogólna budowa funkcji
Do tej pory miałeś okazję niejednokrotnie wykorzystywać istniejące funkcje we własnych programach. Jak zapewne zauważyłeś, wykorzystywanie funkcji jest bardzo wygodne i proste w użyciu. Dobrze by było, gdyby równie proste było pisanie własnych funkcji... i tak w rzeczywistości właśnie jest.
Każda funkcja posiada trzy własności:
zwraca dane (lub nie jeśli tego nie chcemy);
posiada nazwę (bezwarunkowo musi być nazwa o unikatowej nazwie);
może posiadać dowolną ilość parametrów wejściowych (lub może nie mieć żadnego, jeśli tego nie chcemy).
Deklaracja funkcji
Zgodnie z wymienionymi podpunktami ogólna budowa funkcji prezentuje się następująco:
zwracany_typ_danych nazwa_funkcji(parametry_funkcji)
{
//blok funkcji
return(wartosc_zwracana);
}
//Przykładowo:
int MojaPierwszaFunkcjaDodawania(int a,long b=10)
{
//tu można umieścić jakieś jeszcze instrukcje, pętle itp.
//można by powiedzieć, że funkcja to Twój podprogram, któremu dajesz
//jakieś parametry a on na zakończenie daje Ci wynik
//który później wykorzystujesz gdzieś dalej
return(a+b);
}
Co ważnego powinniśmy wiedzieć o funkcjach
Wszystkie zadeklarowane zmienne wewnątrz funkcji lub w parametrach funkcji są widoczne tylko i wyłącznie w obrębie funkcji. Ich modyfikacja nie wpływa na wartości zmiennych poza obrębem funkcji. Parametry funkcji możesz traktować jak zwykłe zmienne wewnątrz funkcji, które różnią się tylko tym, że mają przypisaną wartość podaną podczas wywołania funkcji. Pozostałe informacje przedstawiam w punktach:
Każda funkcja musi mieć unikatową nazwę w obrębie całego programu (są odstępstwa ale o tym później);
Parametry funkcji oddzielone są przecinkami;
Słowo kluczowe void informuje kompilator, że funkcja nie zwraca żadnych danych.
Słowo kluczowe void użyte w miejscu definiowania parametrów funkcji informuje kompilator, że funkcja nie przyjmuje żadnych parametrów;
Parametrom funkcji można przypisywać domyślne wartości, które zostaną użyte wtedy gdy podczas jej wywołania parametr nie zostanie uzupełniony;
Funkcja może zwracać tylko jeden prosty typ danych;
Za pomocą parametrów możemy przekazywać również tablice.
Parametry funkcji przekazywane przez referencję
Jeśli chcemy, aby parametr wejściowy modyfikował wartość zmiennej, którą podajemy jako parametr funkcji, musimy w tym celu wykorzystać referencję. Referencję oznaczamy symbolem & i piszemy go przed nazwą zmiennej. Wygląda to tak:
#include<iostream>
#include<conio.h>
using namespace std;
void PodniesDoPotegiDrugiej(int &liczba)
{
liczba*=liczba;
}
int main()
{
int liczba;
cout<<"Podaj liczbe: ";
cin>>liczba;
PodniesDoPotegiDrugiej(liczba);
cout<<"Liczba="<<liczba<<endl;
getch();
return(0);
}
Jeśli zapomnielibyśmy o referencji (czyli o dodaniu znaku &), wartość zmiennej na zewnątrz funkcji nie uległaby zmianie. W efekcie wyświetliłaby się wartość ta, którą wprowadziliśmy zamiast liczba podniesiona do potęgi drugiej.
Pamiętajmy jednak, że jeżeli używamy referencji to typ zmiennej przekazywanej przez parametr musi być dokładnie taki sam jak parametr w definicji funkcji.
Definicja funkcji
Jeśli chcemy poinformować kompilator, że gdzieś w kodzie (lub poza nim np. w zewnętrznej bibliotece) znajduje się deklaracja funkcji musimy użyć do tego definicji funkcji. Aby zdefiniować funkcję wystarczy napisać:
zwracany_typ_danych nazwa_funkcji(parametry_funkcji);
//Przykładowo
void nowaFunkcja(long,short,bool);
Pisząc definicję funkcji możemy dodatkowo pisać nazwy dla parametrów. Są one jednak ignorowane przez kompilator i pełnią tylko i wyłącznie rolę informacyjną dla użytkownika. Jak pewnie zauważyłeś zamiast bloku głównego na końcu definicji funkcji jest średnik.
Kiedy potrzebujemy definicję funkcji
Definicja funkcji jest nam potrzebna prawie zawsze wtedy, gdy jedna funkcja zależy od drugiej. Najlepiej będzie przytoczyć tu przykład:
#include <iostream>
int ObliczCos(int a,int b);
int Wynik(int a,int b)
{
return(ObliczCos(a,b)*a-b);
}
int ObliczCos(int a,int b)
{
return(a+b*a);
}
int main()
{
return(0);
}
Teraz, jeśli usuniemy z tego programu definicję funkcji to program wyrzuci błąd kompilacji i poinformuje Cię, że nie zna funkcji ObliczCos, którą chce wywołać funkcja Wynik. Jeśli jesteś spostrzegawczy to pewnie zauważyłeś, że gdybyś zamienił kolejność funkcji Wynik i ObliczCos miejscami to niebyła by Ci potrzebna definicja funkcji. Czasami jednak nie da rady dokonać takiej zamiany i będziesz musiał wpisać wcześniej definicję, aby kod mógł Ci się skompilować.
Przeciążanie nazwy funkcji
Jeśli chcemy mieć koniecznie dwie lub więcej funkcji o tej samej nazwie możemy to uczynić pod warunkiem, że lista wszystkich parametrów każdej funkcji będzie różna. Różnica musi być w typie conajmniej jednej zmiennej lub w ilości parametrów, która umożliwi kompilatorowi jednoznacznie określić w momencie wywołania funkcji o którą programiście chodzi. Poniżej zamieszczam przykład przeciążania funkcji.
#include <iostream>
#include <conio.h>
using namespace std;
int PotegaCzwarta(int n)
{
return(n*n*n*n);
}
int PotegaCzwarta(int a,int b)
{
return(PotegaCzwarta(a+b));
}
int main()
{
long long liczba;
cout<<"Podaj liczbe: ";
cin>>liczba;
cout<<"Liczba "<<liczba<<" podniesiona do potegi 4 to "<<PotegaCzwarta(liczba)<<endl;
cout<<"Liczba ("<<liczba<<"+3) podniesiona do potegi 4 to "<<PotegaCzwarta(liczba,3)<<endl;
getch();
return(0);
}
Rekurencja
Jak każdy szanujący się język programowania, C++ daje Ci możliwość tworzenia rekurencji. Rekurencją nazywamy wywoływanie funkcji wewnątrz jej deklaracji. Nieumiejętne posługiwanie się rekurencją może w bardzo łatwy sposób zawiesić Twój program. Wystarczy, że dasz zły warunek wyjścia z rekurencji i wywoływanie będzie zapętlone w nieskończoność. Nieskończoność prędzej czy później w przypadku rekurencji nastanie, ponieważ zasoby pamięciowe komputera są ograniczone. Poniżej zamieszczam funkcję, która liczy silnię i jest napisana rekurencyjnie.
long long Silnia(long long n)
{
if(n<=1) return(1); else return(Silnia(n-1)*n);
}
Wskaźniki
Odczytywanie adresu pamięci istniejących zmiennych
Język C++ w bardzo łatwy sposób umożliwia nam pobieranie adresu pamięci wybranych zmiennych. Wskaźnik zajmuje zazwyczaj 4 bajty bez względu na jaki typ danych wskazuje. Rozmiar wskaźnika może być jednak różny w zależności od użytego kompilatora (np. gdy użyjemy 64 bitowego kompilatora). Wskaźnik zwraca adres pierwszego bajta danych wybranej zmiennej. Aby pobrać adres dowolnej zmiennej wystarczy napisać: &nazwa_zmiennej.
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int zmienna1=213;
int tablica[]={1,2,3,4,5,6,7,8,9,10};
struct
{
int liczba;
long long duzaLiczba;
}struktura;
cout<<"Adres zmienna1="<<&zmienna1<<endl<<endl;
cout<<"Adres tablica="<<&tablica<<endl;
cout<<"Adres tablica[0]="<<&tablica[0]<<endl;
cout<<"Adres tablica[1]="<<&tablica[1]<<endl<<endl;
cout<<"Adres struktura="<<&struktura<<endl;
cout<<"Adres struktura.liczba="<<&(struktura.liczba)<<endl;
cout<<"Adres struktura.duzaLiczba="<<&(struktura.duzaLiczba)<<endl;
getch();
return(0);
}
Zauważmy, że wskaźnik ze zmiennej tablica i ze zmiennej tablica[0] jest taki sam. Dzieje się tak dlatego, że wskaźnik ze zmiennej tablica wskazuje na początek wszystkich danych w tablicy, a pierwszym elementem jest tablica[0]. To samo dotyczy adresu zmiennej struktura i struktura.liczba. Adresy zmiennych są wyświetlane w postaci szesnastkowej.
Deklaracja zmiennej wskaźnikowej
Deklaracja zmiennej wskaźnikowej jest również prosta. Aby utworzyć zmienną wskaźnikową, to po typie zmiennej dopisujemy *. Tak więc, jeśli chcemy utworzyć wskaźnik, który ma wskazywać na liczbę typu long long, zapis ten będzie wyglądał tak:
long long* wskaznik;
Zapisywanie adresu zmiennej do wskaźnika
Aby przypisać adres zmiennej do wskaźnika wystarczy napisać:
long long zmienna;
long long* wskaznik=&zmienna;
Wyświetlanie adresu wskaźnika
Jeśli wypiszemy teraz wartość zmiennej wskaźnik, otrzymamy liczbę wyświetloną szesnastkowo.
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
long long zmienna=213;
long long* wskaznik=&zmienna;
cout<<"&zmienna="<<&zmienna<<endl;
cout<<"wskaznik="<<wskaznik<<endl;
getch();
return(0);
}
Jak pokazuje ten przykład i jak można było się tego spodziewać, wartość wskaźnika jest taka, jaką do niego zapisaliśmy.
Wyświetlanie danych, na które wskazuje adres wskaźnika
Aby wyświetlić dane jakie znajdują się pod adresem jaki mamy zapisany we wskaźniku, musimy przed nazwą zmiennej dopisać *. Tak więc, modyfikując poprzedni program, będzie to wyglądało tak:
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
long long zmienna=213;
long long* wskaznik=&zmienna;
cout<<"zmienna="<<zmienna<<endl;
cout<<"*wskaznik="<<*wskaznik<<endl;
getch();
return(0);}
Modyfikacja danych, na które wskazuje wskaźnik
Mając zapisany adres do zmiennej we wskaźniku, mamy możliwość zmiany wartości zmiennej nie używając nazwy zmiennej, z której pobraliśmy adres. Przykład:
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
long long zmienna=213;
long long* wskaznik=&zmienna;
cout<<"zmienna="<<zmienna<<endl;
*wskaznik=50;
cout<<"zmienna="<<zmienna<<endl;
getch();
return(0);
}
Dostęp do danych struktury za pośrednictwem wskaźnika
Jeśli chcemy odczytać lub zapisać dane do struktury za pomocą wskaźnika wskazującego na nią, postępujemy prawie tak samo jak w przypadku zwykłej zmiennej - poprzedzamy wskaźnik znakiem *. Wskaźnik ten musimy jednak umieścić w okrągłe nawiasy, żeby kompilator wiedział czego się tyczy symbol *. Kolejny przykład:
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
struct daneST
{
int liczba;
char znak;
};
daneST dane;
dane.liczba=55;
daneST* wskaznik=&dane;
cout<<"(*wskaznik).liczba="<<(*wskaznik).liczba<<endl;
(*wskaznik).liczba=99;
cout<<"dane.liczba="<<dane.liczba<<endl;
getch();
return(0);
}
Wskaźniki i struktury po raz drugi
Oprócz przedstawionej wyżej metody uzyskiwania dostępu do danych istnieje również drugi, który jest równoważny pierwszemu. Jest on moim zdaniem wygodniejszy w użyciu, jednak chciałem pokazać Ci różne zapisy ponieważ starsi programiści, którzy 'przesiedli' się z C na C++ korzystają zazwyczaj z pierwszego zapisu. Zamiast poprzedzać zmienną wskaźnikową gwiazdką i wstawiać ją w nawiasy, wystarczy kropkę zastąpić zapisem takim zapisem: ->. Przykład z poprzedniego podrozdziału ze zmodyfikowanym zapisem przedstawiam poniżej.
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
struct daneST
{
int liczba;
char znak;
};
daneST dane;
dane.liczba=344;
dane.znak='a';
daneST* wskaznik=&dane;
cout<<"wskaznik->liczba="<<wskaznik->liczba<<endl;
wskaznik->liczba=221;
cout<<"dane.liczba="<<dane.liczba<<endl;
getch();
return(0);
}
Wyszukiwarka