////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PISZCIE KOLEJNE PYTANIE Z KOLEJNYM NUMEREM - aby sie zrozumieć w odpowiedziach
no to zaczynamy:
1.Co jest w digramie czynności w UML-u.
2.Jaki jest poprawny konstruktor kopiujący klasy student.
student::copy()
Student student::copy()
student(const Student &s)
3.do czego sluzy destruktor ?
do zniszenia obieku
do uwolnienia zaalokowanej pamieci
4.klasa pochodna dziedziczy private(public) po bazowej,jej skladniki:
5.który diagram UML najbardziej przypomina zwykly algorytm
6.kiedy jest klasa abstrackycjna (chyba)
7.dziedziczenie (bazowa -> pochodna/bazowa -> pochodna:
zwierze -> ssak -> koń
sport -> gra -> koszykówka
student -> osoba -> pracownik
wypiek -> ciasto -> babka
kura -> jajko -> jajecznica
8.stworzenie dynamicznej tablicy klasy
klasa *wsk = new klasa [liczba]
klasa *wsk = new tablica [liczba]
klasa *wsk = new klasa[]
9.kto ma dostęp do skladników public/private klasy bazowej?
metody klasy bazowej
metody klasy pochodnej
funkcje zaprzyjaznione
dostep globalny
10.jak mozna zrobic konwersje z klasy pochodnej do bazowej?
operator konwertujacy
konstruktor ..
11.dwuargumantowa funkcja operatorowa
mozna zastapic dwoma jednoargumentowymi
!
argumenty mozna zamienic stronami
12.jak jest wylapywany wyjatek? (samemu)
13.jesli wyjatek jest niespelniony (czy jakos tak,tez samemu cos trza bylo)
14.static (cos)
jest inicjalizowany globalnie
dla wszystkich obiektow danej klasy ma taka sama wartosc
nie mozna zmienic tej wartosci
15.const (cos)
jest inicjalizowany globalnie
dla wszystkich obiektow danej klasy ma taka sama wartosc
nie mozna zmienic tej wartosci
16.jesli klasa jest zadeklarowana,czy pamiec jest zaalokowana?
prawda/falsz
17.jak zmienic domyslne skladniki klasy w klasie? cos takiego
wywolujac jawnie konstruktor bez arg
wywolujac jawnie konstruktor z arg
costam globalnie chyba
18.class A{
virtual f1() - cout A
f2() - cout C
}
class B : class A {
f1() cout B
f2() cout D
)
a &A
b &B
f1()->a
f2()->a
nie pamietam ,jakies takie cos.co zostanie zwrocone bylo pytanie
19.kombinacje rozne ze wskaznikami ktore trzeba bylo zaznaczyc (1 lub wiecej)
wsk+indeks
wsk.indeks
.
->
*(-||-)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jakich operatorow nie mozna przeladowac
.
::
,
new
i jescze jakies 2
odp :: i .
co wyswietli program
class A
{
public:
virtual void f1() {cout << "A" ;}
};
class B: public A
{
public:
void f1() {cout << "B";}
};
f(A a)
{
a.f1()
}
A a;
B b;
f(a);
f(b);
(pomijajac fakt, ze sie nie skompiluje bo funkcja f nie ma typu ) to wyswietli AA
jak nazywa sie przykrywanie (??) zmiennych w klasie
hermetyzacja
+3 inne
cos o to jak diedziczone sa skladniki
nie pamietam jakie byly mozliwosci ale odpowiedzi to:
public -> public
protected -> public
private -> brak dostepu z poziomy klasy pochodnej
(z tego co pamietam to nie bylo takich opcji ; / )
3. do czego sluzy destruktor ?
do zniszenia obieku +
do uwolnienia zaalokowanej pamieci +
6.kiedy jest klasa abstrackycjna (chyba)
kiedy ma chociaz jedna metode nie zapimplementowana (jest sam naglowek metody (deklaracja))
7.dziedziczenie (bazowa -> pochodna/bazowa -> pochodna:
zwierze -> ssak -> koń +
sport -> gra -> koszykówka +
student -> osoba -> pracownik -
wypiek -> ciasto -> babka +
kura -> jajko -> jajecznica -
8.stworzenie dynamicznej tablicy klasy
klasa *wsk = new klasa [liczba] +
klasa *wsk = new tablica [liczba] -
klasa *wsk = new klasa[] -
9.kto ma dostęp do skladników public/private klasy bazowej?
metody klasy bazowej +
metody klasy pochodnej -
funkcje zaprzyjaznione +
dostep globalny -
10.jak mozna zrobic konwersje z klasy pochodnej do bazowej?
operator konwertujacy +
konstruktor .. + (na 90%)
11.dwuargumantowa funkcja operatorowa
mozna zastapic dwoma jednoargumentowymi - (90%)
argumenty mozna zamienic stronami -
12.jak jest wylapywany wyjatek? (samemu)
try{
funkcja ktora moze wywolac wyjatek
}
catch(jaki wyjatek przechwytujemy)
{ pbsluga wyjatku}
13.jesli wyjatek jest niespelniony (czy jakos tak,tez samemu cos trza bylo)
to jest dalej przekazywany jak nigdzie nie jest wychwycony to program sie wywala
14.static (cos)
jest inicjalizowany globalnie +
dla wszystkich obiektow danej klasy ma taka sama wartosc +
nie mozna zmienic tej wartosci -
15.const (cos)
jest inicjalizowany globalnie +
dla wszystkich obiektow danej klasy ma taka sama wartosc +
nie mozna zmienic tej wartosci +
16.jesli klasa jest zadeklarowana,czy pamiec jest zaalokowana?
prawda/falsz pamiec jest deklarowana w momecie uruchominia konstruktora
czyli -
+ dobrze/ - źle
To robił mój brat na szybko (4 rok PPT) ale ja nie daje za to głowy
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Mam kilka zastrzeżeń co do odpowiedzi ATT, test zdałem na 4,5.
"sport -> gra -> koszykówka +" - nie zgadzam się, nie każda gra jest sportem, to sport jest zawsze grą
"12.jak jest wylapywany wyjatek? (samemu)
try{
funkcja ktora moze wywolac wyjatek
}
catch(jaki wyjatek przechwytujemy)
{ pbsluga wyjatku}"
ważne jest także słówko "throw"(w bloku try{}) miałem odnośnie niego pytanie, tzn wpisałem je. A brzmiało jakoś tak "Dzieki czemu wyjątek może być złapany?"
"16.jesli klasa jest zadeklarowana,czy pamiec jest zaalokowana?
prawda/falsz pamiec jest deklarowana w momecie uruchominia konstruktora
czyli -
+ dobrze/ - źle"
Nie zgadzam się, klasa jest tylko deklaracją typu, a pamięć jest raczej alokowana przy tworzeniu obiektu tej klasy.
Z resztą się zgadzam, wyjątkiem jest 10., nie chce mi się nad tym teraz myśleć, idę odpocząć :p
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Miałem 2 pytania z UML'a, NIE jestem pewny czy dobrze odpowiedziałem:
1. Który diagram przypomina klasyczny algorytm? (Brałem pod uwagę tylko 3 odpowiedzi,a było 5)
-klas
+czynności
-stanów
2. Co można zobaczyć w diagramie czynności? (Chyba inaczej to brzmiało ale kminicie):
+związki
-agregacje
-przypadki użycia
<były jezscze 3, z czego 2 zaznaczyłem>
Inne pytania (na 100%) dobrze:
3. Która z odpowiedzi umożliwia konwersję:
+ Osoba(const Osoba &o)
- void Osoba (const Osoba &o)
<reszta odpowiedzi była bez sensu>
4. Chodziło o to że przy dziedziczeniu dopisujemy "private" i co się wtedy dzieje z prawami dostępu (banał :]):
+wszystkie -> private
+public -> private
<reszta była źle>
Jak sobie coś przypomnę postaram się dodać :]
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Mój kolega, doświadczony informatyk, któremu pokazałem te nasze pytania z forum ma kilka uwag:
3. Która z odpowiedzi umożliwia konwersję:
+ Osoba(const Osoba &o)
- void Osoba (const Osoba &o)
<reszta odpowiedzi była bez sensu>
(raczej) + smieszne takie....
np
coś w stylu: A(const B& b);
obiekt A przyjmuje w konstruktorze obiekt B. I sam tworzy sie na podstawie obiektu B
hmm. ciezko podac przyklad. czasem sie stosuje tak, ale rzadko
4.do czego sluży destruktor ?
- do zniszczenia obiektu
+ do uwolnienia zaalokowanej pamięci
destruktor sluzy do posprzatania po sobie. np zamkniecia otwieranych socketow, plikow, zniszczania wlasnych obiektow
samo zwalnianie pamieci jest juz robione za destruktorem
5.klasa pochodna dziedziczy private(public) po bazowej, jej składniki:
Wszystkie: private, public, protected
jak dziedziszych private to wtedy zmieniasz widocznosc zmiennych wszystkich na private. czyli jak B dziedziczy private A, i C dziedziczy z B, to C nie widzi zmiennych A
jakbys dziedziczyl public to nic sie nie zmienia
a protected to tylko public zmienia na protected
dziedziczy wszystko tyle ze ze zmienionym dostępem
10.kto ma dostęp do składników private klasy bazowej?
+ metody klasy bazowej
- metody klasy pochodnej
+ funkcje zaprzyjaźnione
- dostęp globalny
10.kto ma dostęp do składników protected klasy bazowej?
+ metody klasy bazowej
- metody klasy pochodnej
+ funkcje zaprzyjaźnione
- dostęp globalny
+ metody klasy pochodnej
15.static (cos)
+ jest inicjalizowany globalnie
+ dla wszystkich obiektów danej klasy ma taka sama wartość
- nie można zmienić tej wartości
16.const (cos)
- jest inicjalizowany globalnie
- dla wszystkich obiektów danej klasy ma taka sama wartość
+ nie można zmienić tej wartości
15 pytanie o static to tak. jest globalna zmienna. natomiast 16. const nie musi byc static
moze byc cosnt, moze byc static a moze byc const static
samo const zabespiecza tylko ze nie mozesz zmienic wartosci
czyli tylko ostatnia jest prawidlowa
17.const static (cos)
+ jest inicjalizowany globalnie
+ dla wszystkich obiektów danej klasy ma taka sama wartość
+ nie można zmienić tej wartości
19.class A{
virtual f1() - cout A
f2() - cout C
}
class B : class A {
f1() cout B
f2() cout D
)
a &A
b &B
f1()->a
f2()->a
nie pamiętam, jakieś takie coś, co zostanie zwrócone było pytanie
„BC”
21. Jaka funkcja jest wywoływana podczas wystąpienia błędu? (pyt. otwarte)
Wyjatek?
bo podczas bledu to nic nie jest wywolywane. jak zrobisz dzielenie przez 0, wyjdziesz po za zakres tablicy czy inny glupi blad to dostaniesz program wykonal nie dozwolona operacje i nastapilo jego zamkniecie
a z wyjatkiem to nawet nie wiem
z wyjatkiem to poprostu ktorys catch wylapie, a nawet nie wiem czy cos jest wywoływane
23. Zadanie typu:
class A {
...
} // nie jestem pewien tej klamry
class B {
A obiekt // czy coś w tym stylu
}
Pytanie: czy obiekt utworzony w klasie B będzie obiektem typu A?
jesli dobrze rozumiem pytanie to nie
jesli B zawiera A, a ty stworzysz obiekt klasy B to to jest obiekt klasy B a nie A
gdyby B dziedziczylo z A, to wtedy tak
samochod jest pojazdem
ale samochod nie jest kolem
kołem
24. co wyświetli program
class A
{
public:
virtual void f1() {cout << "A" ;}
};
class B: public A
{
public:
void f1() {cout << "B";}
};
f(A a)
{
a.f1()
}
A a;
B b;
f(a);
f(b);
to chyba powinno byc: f(A& a) zamiast f(A a)
wypisze „AB”!!
jest virtual
i masz obiekty a i b
i przekazujesz je do funkcji polimorficznej
ona je obie widzi jako a
ale jeden z tych a to jest b
25. jakich operatorów nie można przeładować
+ .
+ ::
,
- New
- delete
i jeszcze jakieś 2
odp. :: i .
26. jak nazywa się przykrywanie (??) zmiennych w klasie
hermetyzacja
+3 inne
: hermetyzacja a przykrywanie to 2 rozne rzeczy!!!
hermetyzacja polega na tym, by nie udostepniac bebechow na zewnatrz
moze powinno byc:
26. jak nazywa się blokowanie dostepu do zmiennych w klasie
hermetyzacja
+3 inne
27. nie pamiętam jakie były możliwości ale odpowiedzi to:
public -> public
protected -> public
private -> brak dostepu z poziomy klasy pochodnej
(z tego co pamiętam to nie było takich opcji ; / )
to pewnie pytaja o to do czego klasa pochodna ma dostep w bazowej
to tak. ma do public i protected dostep
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
OBIEKTOWKA TEST GLOWACKI-GOLENKO
by Radziu
Konstruktor - Specjalna funkcja składowa, która nazywa się tak samo jak klasa
• W ciele możemy zamieścić instrukcje nadające składnikom obiektu wartości początkowe
• Konstruktor sam nie przydziela pamięci na obiekt
• Konstruktor jest automatycznie uruchamiany przy definiowaniu każdego obiektu danej klasy
• Konstruktor można przeładowywać - może być kilka w jednej klasie
• Konstruktor nic nie zwraca - ale nie jest typu void !!!
• Konstruktor może być jawnie wywołany - nazwa_klasy (argumenty )
• Konstruktor domniemany (można go wywołać bez żadnych argumentów) - nazwa klasy(void)
• Konstruktor może być nie publiczny
• Kon struktur kopiujący - inicjalizator kopiujący
o Wywołanie : klasa::klasa( klasa &) -Argumentem jest referencja
o Konstruktor kopiujący służy do skonstruowania obiektu który jest kopią innego już istniejącego obiektu tej klasy
o Konstruktor kopiujący może być wywołany z jednym argumentem lub zwiększą ich ilością pod warunkiem ze pozostałe są domniemane
o Konstruktor kopiujący nie jest obowiązkowy jeżeli go nie zdefiniujemy kompilator zrobi to sam
o Konstruktor kopiujący może zostać wywołany jawie lecz jest on również wywoływany bez naszej wiedzy
o Deklaracja: klasa( klasa & kl)
Destruktor- destruktor jest funkcją składową o nazwie ~nazwa _klasy jest wywoływany automatycznie zawsze gdy obiekt jest likwidowany
• Klasa nie musi mieć destruktora
• Destruktor nie likwiduje obiektu
• Destruktor nie zwalnia obszaru pamięci
• Destruktor jest używany wtedy gdy przed zniszczeniem obiektu trzeba wykonać jakies działania - posprzątać , dodać do licznika itp.
• Destruktor nie może nic zwracać - nie mylić z VOID !!!
• Destruktor jest bezargumentowy a wiec nie może być przeładowany
• Destruktor można wywołać jawnie - obiekt.~klasa();
Konwersja - przekształcenie obiektu jedno typu w drugi
• Aby dokonać konwersji klasy A do klasy Z potrzebujemy :
o Albo konstruktor klasy Z przyjmujący jako jedyny argument obiekt typu A
o Albo specjalna funkcja składowa klasy A zwana funkcją konwertującą
• Konwersje mogą być przeprowadzane nie jawnie (samoczynnie)
o dzieje się tak wtedy gdy zachodzi niedopasowanie Typu
o gdzy przy zwracaniu obiekt stojący przy return jest innego typu niż zadeklarowany przy deklaracji funkcji
o w obecności operatorów
o wyrażenia inicjalizujące
• Konwersje możemy wywołać jawnie
• Konstruktor jako konwerter :
klasa ::klasa(argument r )
{
Skladowa klasy = r;
}
Konwersja typu argument na typ klasa
• Funkcja konwertująca - operator konwersji
Funkcja konwertująca jest funkcją składową klasy K która się nazywa
K::operator T()
Gdzie t jest nazwą typu na który chcemy dokonać konwersji (T może być nazwą typu wbudowanego )a K nazwa typu który chcemy przekonwertować .
• Jawne wywołanie konwersji typów :
o Jeżeli zadeklarowane za pomocą konstruktora : inny:inny(zespol z, int i=16);
Drugi argument jest domniemany , ten konstruktor da się wywołać tylko z jednym argumentem typu zespol
Wywołania
N=inny(zzz);
N=inny(zzz, 333)
Gdzie zzz to obiekt klasy typu Zespol
o Gdy zadeklarowane za pomocą funkcji konwertującej w klasie : A::operator char*()
To wywołanie wygląda tak :
Napis =(char*)obj
Dziedziczenie(tworzenie klas pochodnych) to technika pozwalająca na definiowanie nowej klasy przy wykorzystaniu klasy już wcześniej istniejącej .
• W klasie pochodnej możemy :
o Zdefiniować dodatkowe dane składowe
o Zdefiniować dodatkowe funkcje składowe
o Zdefiniować składnik, funkcje składową która istnieje w klasie bazowej
• Przykładową definicja klasy pochodnej :
class klasa_pochodna : public klasa_bazowa {
public :
char coś tam; //dodatkowy składnik
klasa _pochodna (float=0, int=0, char =d); ///konstruktor w którym float i int pochodzą z funkcji bazowej
void wypisz (); // dodatkowa funkcja
};
• Jeżeli w klasie pochodnej zadeklarujemy taki sam składnik lub funkcje jak w klasie bazowej to wówczas składniki klasy pochodnej przesłaniają składniki klasy bazowej w zakresie klasy pochodnej.
• Dostęp do składników :
o Prywatne składniki klasy bazowej są dziedziczone lecz nie mamy do nich dostępu z poziomu klasy pochodnej
o Składniki protected są dziedziczone i mammy do nich dostęp z poziomu ksy pochodnej
o Składniki public są dziedziczone i mamy do nich dostęp z poziomu klasy pochodnej i wszystkiego innego na około : funkcji globalnych itp.
• Dziedziczenie ze zmianą praw dostępu do składników odziedziczonych :
o Dziedziczenie public :składniki public dziedziczą się na public , składniki protected na protected : class pochodna : public bazowa {ciało };
o Dziedziczenie protected : składniki public i protected dziedziczą się na protected
: class pochodna : protected bazowa {ciało };
o Dziedziczenie Privatre : public i protected dziedziczą się na private.
class pochodna : private bazowa {ciało };
Należy pamiętać że składniki private dziedziczą się zawsze na private ale nigdy nie mamy do nich dostępu czylio tak jakby się nie dziedziczyły
• czego się nie dziedziczy :
o Konstruktory
o Operator przypisania
o Destruktor
• Dziedziczenie może być wielo stopniowe
• Kostruktory są wywoływane w następującej kolejności : basowa , pochzodna1, pochodna 2 …
• Klasa pochodna nie definiuje swojego operatora przypisania
Przeładowanie operatorów - pozwala na zmianę działania operatorów np. + przeładowujemy aby dodawał nam dwa składniki naszej klasy ( domyślnie potrafi on dodawać tylko liczby które są typu wbudowanego)
• Operatory które mogą być przeładowanie :
o +
o -
o *
o /
o %
o ^
o &
o |
o ~
o !
o =
o <
o >
o +=
o -=
o *=
o /=
o %=
o ^=
o &=
o |=
o <<
o >>
o >>=
o <<=
o ==
o !=
o <=
o >=
o &&
o ||
o ++
o -
o ,
o ->*
o ->
o New
o Delete
o ()
o []
• Operatory które nie mogą być przeładowane :
o .
o .*
o ::