#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
ostream strumien1, strumien2;
int main()
{
strumien1 = strumien2 = cout;
strumien1 << " Napis1 ";
strumien2 << " Napis2 " << endl;
return 0;
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
1.OpisPytania
... na wyjsciu standardowym pojawi sie napis:
Napis1 Napis2
NIE
2.OpisPytania
... nic sie nie pojawi, gdyz program zawiera blad.
TAK
3.OpisPytania
... nic sie nie pojawi, gdyz dla strumieni operacja przypisania
nie jest dozwolona.
TAK
4.OpisPytania
... nic sie nie pojawi, gdyz wielokrotne przypisywanie dla strumieni
nie jest mozliwe. Nalezaloby to rozwiazac za pomoca pojedynczych
przypisan, tj.
strumien1 = cout; strumien2 = cout;
NIE
#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
ostream &strumien1 = cout, &strumien2 = strumien1;
int main()
{
strumien1 << " Napis1 ";
strumien2 << " Napis2 " << endl;
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
5.OpisPytania
... na wyjsciu standardowym pojawi sie napis:
Napis1 Napis2
TAK //ale brakuje return, ale to chyba bez różnicy….
6.OpisPytania
... na wyjsciu standardowym pojawi sie napis:
Napis1 Napis2
Jednak program moze spowodowac blad wykonania,
gdyz operacje tego typu nie sa dozwolone.
NIE wydaje mi sie
7. OpisPytania
... moze powstac blad, aczkolwiek nie musi,
gdyz "strumien2" jest referencja do referencji.
Chyba tak, jeśli nie zdefinujemy pierw referencji do strumien1
8.OpisPytania
... operujac na zmiennych referencyjnych "strumien1" i "strumien2",
wykonujemy operacje na strumieniu wyjscia standardowego reprezentowanym
przez obiekt "cout".
TAK
#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
class FiguraGeom {
public:
virtual void Wyswietl() { cout << " FiguraGeom" << endl; }
};
class Kwadrat: public FiguraGeom {
public:
virtual void Wyswietl() { cout << " Kwadrat" << endl; }
};
int main()
{
Kwadrat *wKwd = new Kwadrat;
FiguraGeom *wFig = wKwd;
wFig->Wyswietl();
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
9.OpisPytania
... w programie wystepuje niezgodnosci typow w podstawieniu:
FiguraGeom *wFig = wKwd;
W tym przypadku nie jest mozliwe niejawne rzutowanie "w gore".
NIE
10.OpisPytania
... na ekranie pokaze sie napis:
Kwadrat
Jest to wynik dzialania metody "Wyswietl" z klasy "Kwadrat".
TAK
11.OpisPytania
... ponizsze podstawienie moze spowodowac blad.
FiguraGeom *wFig = wKwd;
Powodem jest wystepowanie metod wirtualnych w definicjach klas.
NIE wydaje mi sie
12.OpisPytania
... obiekt klasy "Kwadrat" zawiera w sobie obiekt klasy "FiguraGeom".
CHYBA NIE, ma metode majaca zastąpić obiekt klasy „FiguraGeom”
13.OpisPytania
... domyslne destruktory dla klas "FiguraGeom" i "Kwadrat" nie sa
destruktorami wirtualnymi.
TAK (chyba)
#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
class KlasaA {
public:
virtual ~KlasaA() {}
};
class KlasaB: public KlasaA {
public:
~KlasaB() {}
};
int main()
{
KlasaB *wObiektB = new KlasaB;
KlasaA *wObiektA = wObiektB;
delete wObiektA;
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
14.OpisPytania
... zapis programu jest prawidlowy i destrukcja obiektu przebiegnie wlasciwie.
W tym przypadku brak slowa kluczowe "virtual" przed destruktorem klasy "KlasaB"
nie ma zadnego znaczenia.
TAK
15.OpisPytania
... sam zapis programu jest prawidlowy. Jednak uruchomienie programu moze
powodowac jego bledne dzialanie. Aby temu zapobiec nalezaloby zmienic
linie:
KlasaA *wObiektA = wObiektB;
na linie:
KlasaA *wObiektA = static_cast<KlasaA*>(wObiektB);
KoniecOpisu
NIE
16.OpisPytania
... destruktor klasy "KlasaB" jest destruktorem wirtualnym mimo
braku slowa kluczowego "virtual".
TAK
17.OpisPytania
... w programie w linii:
KlasaA *wObiektA = wObiektB;
zachodzi niejawne rzutowanie "w gore". Jest ono mozliwe tylko i wylacznie
dzieki temu, ze klasa "KlasaA" posiada destruktor wirtualny.
TAK
NIE, rzutowanie w górę jest zawsze możliwe!
#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
class KlasaA {
};
class KlasaB: public KlasaA {
};
int main()
{
KlasaA *wObiektA = new KlasaB;
KlasaB *wObiektB = wObiektA;
return 0;
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
18.OpisPytania
... w programie w linii:
KlasaB *wObiektB = wObiektA;
wystepuje niedozwolona proba rzutowania "w dol".
TAK
19.OpisPytania
... w programie w linii
KlasaB *wObiektB = wObiektA;
wystepuje rzutowanie "w dol", ktore bedzie poprawne jesli
zastosowany zostanie operator jawnego rzutowania w postaci:
KlasaB *wObiektB = static_cast<KlasaB*>(wObiektA);
TAK
20.OpisPytania
... w programie w linii:
KlasaB *wObiektB = wObiektA;
rzutowanie "w dol" byloby poprawne, gdyby zostal
w odpowiedni sposob zdefiniowany wirtualny destruktor w klasie "KlasaA".
NIE sądze
NIE
21.OpisPytania
... w programie w linii:
KlasaA *wObiektA = new KlasaB;
nie ma bledu zapisu polecenia. Jednak wykonanie tej operacji moze powodowac
(aczkolwiek nie zawsze musi) blad i przerwanie dzialania programu w momencie
wykonania tej instrukcji.
NIE sądze żebu powodowało bląd. Co jak zabraknie pamięci ?
#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
class KlasaA {
public:
void Wyswietl() { cout << " KlasaA" << endl; }
};
class KlasaB: public KlasaA {
public:
virtual void Wyswietl() { cout << " KlasaB" << endl; }
};
int main()
{
KlasaA *wObiektA = new KlasaB;
wObiektA->Wyswietl();
return 0;
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
22.OpisPytania
... wykonana zostanie metoda z klasy "KlasaA". Jest ona metoda
wirtualna, co wynika z definicji metody o tej samej nazwie
w klasie "KlasaB".
Wykona się ale nie wiem czy jest wirtualna, chyba bylaby jakby było napisane virtual
NIE, nie jest wirtualna
23.OpisPytania
... wykona sie metoda z klasy "KlasaA". Aby uruchomic metode z klasy
"KlasaB" nalezaloby najpierw dokonac rzutowania "w dol",
tzn.
static_cast<KlasaB*>(wObiektA)->Wyswietl();
TAK
#=========================================================================
Dany jest nastepujacy fragment kodu:
#include <iostream>
using namespace std;
class KlasaA { int _PoleA; };
class KlasaB: public KlasaA { int _PoleB; };
int main()
{
KlasaB *wObiektB = new KlasaB;
KlasaA *wObiektA = wObiektB;
if (wObiektA == wObiektB) cout << "Rownosc nr 1" << endl;
}
Powyzszy kod jest poprawny pod wzgledem skladni i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
24.OpisPytania
... operacja porownania wskaznikow jest poprawna. Regula ta obejmuje wszystkie
przypadki tego typu niezaleznie od zlozonosci wewnetrznej struktury obiektu
i podobiektu.
TAK ??
25.OpisPytania
... operacja ta da wlasciwy wynik tylko i wylacznie wtedy, gdy w klasach
beda zdefiniowane destruktory wirtualne.
NIE
26.OpisPytania
... w tym przypadku zachodzi rownosc tylko i wylacznie ze wzgledu
na to, ze klasa "KlasaA" jest bezposrednio dziedziczona przez
klase "KlasaB".
TAK
27.OpisPytania
... operacja porownania powoduje niejawne rzutowanie zawartosci zmiennej
wskaznikowej "wObiektB" na wskaznik typu: KlasaA*
TAK
28.OpisPytania
... w programie wykorzystane jest niejawne rzutowanie wskaznikow.
W tym przypadku niejawne rzutowanie nie jest zwiazane z hierarchia
dziedziczenia klas.
NIE?
#=========================================================================
Dany jest fragment kodu:
vector<double> Tab(5);
double &Zm = Tab[1];
Tab.push_back(10);
Zm = Tab[5];
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
29.OpisPytania
... jesli kod wykona sie poprawnie, to po ostatnim podstawieniu
moze zachodzic warunek:
Zm == 10
Konstrukcja ta jest jednak niepoprawna, gdyz poprzez zmienne
"Zm" mozliwe jest odwolanie do niewlasciwego obszaru pamieci.
TAK (Wg mnie NIE)
NIE
30.OpisPytania
... po wykonaniu tego kodu zawsze zachodzi warunek:
Tab[1] == Tab[5]
KoniecOpisu
NIE
#=========================================================================
Dany jest fragment kodu:
vector<double> Tab(5);
double &Zm = Tab[1];
Tab.push_back(10);
Zm = Tab[5];
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
31.OpisPytania
... po wykonaniu tego kodu zawsze zachodzi warunek:
&Zm == &Tab[1]
NIE
32.OpisPytania
... po wykonaniu tego kodu zawsze zachodzi warunek:
Zm == Tab[1]
NIE
#=========================================================================
Niech dana bedzie deklaracja zmiennej:
list< vector< double> > Lst(5);
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
33.OpisPytania
... w podstawieniu przedstawionym ponizej
Lst.back()[1] = 5;
nastepuje proba modyfikacji drugiej skladowej wektora,
ktory jest piatym elementem listy?
MEMORY COULD NOT BE READ, ale chyba nie...
34.OpisPytania
... wszystkie wektory wchodzace w sklad utworzonej listy maja
rozmiar zerowy (tzn. metoda size() w ich przypadku zwraca 0).
JAK DLA MNIE TO NIE BO MOŻE GDZIES DODAJEMY JAKIES DANE TAM
#=========================================================================
Niech dany bedzie fragment kodu:
list< vector< double> > Lst(5);
Lst.back()[1] = 5;
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
35.OpisPytania
... wykonane podstawienie spowoduje utworzenie drugiej skladowej
w ostatnim wektorze listy 'Lst'.
36.OpisPytania
... zmienna 'Lst' reprezentuje liste wektorow, ktore maja
po piec skladowych.
JAK DLA MNIE TO NIE
#=========================================================================
Dany jest program:
struct Wektor2f {
float _x, _y;
Wektor2f(float w): _x(w), _y(w) {}
operator float () const { return _x*_x + _y*_y; }
};
int main()
{
Wektor2f Wek = 1;
float Liczba;
Liczba = 2 + Wek * 2;
}
Jest on prawidlowy pod wzgledem skladni.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
37.OpisPytania
... po wykonaniu ostatniego dzialania zmienna 'Liczba' zawierac
bedzie wartosc 10.
NIE
38.OpisPytania
... w trakcie realizacji ostatniego dzialania w funkcji main,
tzn. operacji: Liczba = 2 + Wek * 2;
nastepuje niejawna konwersja obiektu 'Wek' do zmiennej tymczasowej
typu float.
TAK, przy tej operacje operator float() wywoluje metode zapisana w kalsie
39.OpisPytania
... w tym przypadku zapis: Wektor2f Wek = 1;
jest identyczny z zapisem: Wektor2f Wek(1);
gdyz w obu przypadkach nastepuje wywolanie jedynie
konstruktora klasy 'Wektor2f'.
Tak
40.OpisPytania
... w funkcji 'main' wystepuje wywolanie konstruktora
klasy 'Wektor2f' oraz jedna niejawna konwersja
obiektu klasy 'Wektor2f' do zmiennej typu float.
Tak mi się wydaje
#=========================================================================
Niech dany bedzie fragment kodu:
list <vector< double> > Lst(5);
vector<double> TabWekt[4] = { vector<double>(5), vector<double>(4) };
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
41.OpisPytania
... po wykonaniu tego kodu prawdziwy bedzie warunek:
TabWekt[2].size() == TabWekt[3].size()
TAK
42.OpisPytania
... po wykonaniu tego kodu prawdziwy bedzie warunek:
TabWekt[0].size() == TabWekt[3].size()
NIE
#=========================================================================
Niech dany bedzie fragment kodu:
list <vector< double> > Lst(5);
vector<double> TabWekt[4] = { vector<double>(5), vector<double>(4) };
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
43.OpisPytania
... po wykonaniu tego kodu prawdziwy bedzie warunek:
TabWekt[0].size() == Lst.size()
TAK
44.OpisPytania
... po wykonaniu tego kodu prawdziwy bedzie warunek:
TabWekt[3].size() == Lst.size()
NIE
#=========================================================================
OpisProblemu
Niech dany bedzie fragment kodu:
vector<double> Wekt(4);
double *wskA = &*Wekt.begin();
double *wskB = &*Wekt.end();
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
45.OpisPytania
... wskaznik "wskA" zawiera adres pierwszego elementu
dostepnego poprzez obiekt "Wekt"?
TAK
46.OpisPytania
... wskaznik "wskB" zawiera adres ostatniego elementu
dostepnego poprzez obiekt "Wekt"?
TAK
#=========================================================================
OpisProblemu
Niech dany bedzie fragment kodu:
list<double> Lst(4);
double *wskA = &Lst.front();
Lst.push_back(10);
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
47.OpisPytania
... do drugiego elementu listy mozna odwolac sie w nastepujacy sposob:
*++Lst.begin();
TAK
48.OpisPytania
... wywolanie metody "push_back" spowoduje realokacje pamieci dla
calej listy i dlatego po jej wykonaniu adres w zmiennej "wskA"
moze juz nie byc adresem pierwszego elementu?
NIE
#=========================================================================
Niech dany bedzie fragment kodu:
class KlasaBazowa { };
class KlasaPochodna: public KlasaBazowa { };
void funkcja(const KlasaBazowa &) { }
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
49.OpisPytania
... ponizej zaprezentowane wywolanie funkcji jest prawidlowe?
funkcja( KlasaPochodna() );
TAK
50.OpisPytania
... ponizej zaprezentowane wywolanie funkcji jest prawidlowe?
funkcja( new KlasaPochodna() );
NIE
#=========================================================================
OpisProblemu
Niech dany bedzie fragment kodu:
class KlasaBazowa { };
class KlasaPochodna: public KlasaBazowa { };
void funkcja(const KlasaPochodna &) { }
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
51.OpisPytania
... ponizej zaprezentowane wywolanie funkcji jest prawidlowe?
funkcja( *static_cast<KlasaBazowa*>(&KlasaPochodna()) );
TAK
52.OpisPytania
... ponizej zaprezentowane wywolanie funkcji jest prawidlowe?
funkcja( KlasaBazowa() );
TAK
#=========================================================================
Niech dany bedzie fragment kodu:
struct KlasaA {
int _PoleA;
KlasaA(int Wart) { _PoleA = Wart; }
};
struct KlasaB {
KlasaA _PoleKlasyA;
KlasaB();
};
Zakladamy, ze powyzszy kod jest umieszczony we wlasciwym
kontekscie i kompiluje sie bez zadnych ostrzezen.
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
53.OpisPytania
... ponizsza implementacja konstruktora klasy "KlasaB"
wymusi uruchomienie konstruktora klasy "KlasaA" z parametrem
o wartosci 10 w celu wlasciwego zainicjalizowania pola "_PoleKlasyA"?
KlasaB::KlasaB(): _PoleKlasyA(10)
{ }
TAK
54.OpisPytania
... ponizsza implementacja konstruktora klasy "KlasaB"
wymusi uruchomienie konstruktora klasy "KlasaA" z parametrem
o wartosci 10 w celu wlasciwego zainicjalizowania pola "_PoleKlasyA"?
KlasaB::KlasaB(): KlasaA(10)
{ }
NIE, błąd programu
#=========================================================================
OpisProblemu
Dana jest nastepujaca deklaracja zmiennych:
int kk, &ll=kk, &mm=ll;
#-------------------------------------------------------------------------
55.OpisPytania
Czy po wykonaniu nastepujacych operacji:
kk=2;
ll=5;
mm=7;
zmienna kk bedzie miala wartosc 7 ?
TAK
56.OpisPytania
Czy spelniony jest ponizszy warunek?
&kk == &mm
TAK
#=========================================================================
Nastepne pytanie dotyczyc bedzie referencji i zmiennych referencyjnych:
#-------------------------------------------------------------------------
57.OpisPytania
Czy poprawne jest stwierdzenie:
Przekazywanie parametru funkcji przez referencje
polega na tym, ze do funkcji przekazywany jest parametr
aktualny, a nie tylko jego wartosc.
Dzieki temu zmiany wartosci parametru w funkcji sa widziane
rowniez na "zewnatrz" tej funkcji.
TAK
58.OpisPytania
Czy poprawne jest stwierdzenie:
Jako wynik funkcji wolno przekazywac referencje do
zmiennych lokalnych tej funkcji, poniewaz zmienne te
istnieja caly czas podczas dzialania danej funkcji.
NIE
#=========================================================================
Pytanie dotyczyc bedzie przeciazania funkcji i metod.
KoniecOpisu
#-------------------------------------------------------------------------
59.OpisPytania
Czy funkcje przeciazone to funkcje majace wspolna sama nazwe
(przy czym wielkosc liter jest nieistotna), lecz rozniace sie
np. liczba parametrow lub typami parametrow?
NIE
60.OpisPytania
Czy prawdziwe jest stwierdzenie, ze w jezyku C++ mozna przeciazac
funkcje, a nie mozna przeciazac operatorow arytmetycznych
poza obrebem (definicji) danej klasy?
NIE
61.OpisPytania
Czy poprawna jest nastepujaca definicja przeciazenia
operatora przesuniecia bitowego dla strumienia wyjsciowego.
std::ostream &operator << ( std::ostream &strumien1, std::ostream &strumien2 )
{
return strumien2;
}
TAK
#=========================================================================
Pytanie dotyczyc bedzie hermetyzacji danych i metod
oraz funkcji zaprzyjaznionych
#-------------------------------------------------------------------------
62.OpisPytania
Czy hermetyzacja komponentow klasy (pol lub metod) ma na
celu zabezpieczenie ich przed modyfikacja lub wywolaniem przez
inne metody tej samej klasy?
NIE
63.OpisPytania
Czy metody prywatne (private) i chronione (protected) klasy
dostepne sa dla funkcji zaprzyjaznionych z ta klasa?
TAK ??
64.OpisPytania
Czy dozwolona jest modyfikacja pol prywatnych danej
klasy w funkcjach zaprzyjaznionych z ta klasa?
TAK
#=========================================================================
OpisProblemu
Pytanie dotyczyc bedzie konstruktorow i destruktorow.
KoniecOpisu
#-------------------------------------------------------------------------
65.OpisPytania
Czy prawdziwe jest ponizsze stwierdzenie:
Jezeli dla klasy "KlasaA" nie zostal zdefiniowany zaden
konstruktor, to przy deklarowaniu w programie glownym
zmiennej danej klasy, np.:
KlasaA ObiektA;
zostanie wywolany domyslny konstruktor kopiujacy?
NIE
66.OpisPytania
Czy jedna z operacji powodujacej niejawne wywolanie
konstruktora danej klasy jest dynamiczna alokacja
obiektu tejze klasy za pomoca operatora "new" ?
TAK
67.OpisPytania
Czy destruktory sa zawsze wywolywane niejawnie w przypadku
zmiennych deklarowanych lokalnie (np. w metodzie lub funkcji),
gdy sterowanie osiagnie koniec zakresu waznosci deklaracji danego
obiektu.
TAK ??
#=========================================================================
OpisProblemu
Pytanie dotyczyc bedzie konstruktorow i destruktorow.
KoniecOpisu
#-------------------------------------------------------------------------
68.OpisPytania
Czy prawda jest, ze:
Destruktor powinien miec taka sama
liste parametrow w wywolaniu jak konstruktor.
NIE
69.OpisPytania
Niech bedzie dana definicja klasy:
class LZespolona {
private:
double _re, _im;
public:
LZespolona() { _re = _im = 0;}
};
Czy klasa ta zawiera konstruktor kopiujacy (jawny lub niejawny, o ile
taki moze istniec w tym przypadku).
TAK
#=========================================================================
OpisProblemu
Czy konstruktor ...
KoniecOpisu
#-------------------------------------------------------------------------
70.OpisPytania
... jest metoda skladowa klasy, ktora
zawsze inicjalizuje pola tej klasy?
TAK
71.OpisPytania
... ma taka sama nazwe jak nazwa klasy i
moze byc wywolany jawnie jak kazda metoda.
NIE
72.OpisPytania
... moze byc zadeklarowany w ponizszy sposob:
class Klasa {
Klasa(Klasa);
public:
};
NIE
#=========================================================================
Czy przciazanie metod klasy ...
KoniecOpisu
#-------------------------------------------------------------------------
73.OpisPytania
... jest mozliwe tylko poza sekcja chroniona (protected) danej klasy.
NIE , poza private
74.OpisPytania
... jest zabronione w przypadku destruktora.
NIE ??
75.OpisPytania
... wykorzystujace argumenty domyslne moze prowadzic
do niejednoznacznosci, tzn. z zapisu wywolania metody
bez znajomosci wartosci argumentow domyslnych nie
bedzie mozna stwierdzic, ktora metoda bedzie wywolana?
Pytanie dotyczy definicji w programie, ktory kompiluje sie
poprawnie i nie wystepuja zadne ostrzezenia.
NIE
#=========================================================================
OpisProblemu
Niech bedzie dana definicja:
int numer::funkcja(int i)
{
...
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
76.OpisPytania
... moze to byc definicja metody dla klasy lub struktury lub unii
lub tez unii o nazwie "numer"?
TAK
77.OpisPytania
jezeli jest to metoda klasy "numer", to jej definicja
jest umieszczona na pewno poza blokiem definicji tej klasy?
TAK
#=========================================================================
OpisProblemu
Mamy zdefiniowana klase "KlasaA" i jej klase pochodna
"KlasaB":
class KlasaA {
int _Pole;
public:
KlasaA(int a) { _Pole = a; };
};
class KlasaB : public KlasaA {
public:
int Oblicz();
};
Czy prawda jest, ze ...
KlasaB ob(2);
#-------------------------------------------------------------------------
78.OpisPytania
... Obiekt 'ob' nie bedzie mogl byc utworzony ze wzgledu na brak
konstruktora parametrycznego?
TAK
79.OpisPytania
... zapis jest poprawny i dziedziczone pole '_Pole'
zostanie zainicjalizowane wartoscia 2?
NIE
80.OpisPytania
... zapis deklaracji obiektu "ob" jest poprawny, jednak pole
o nazwie "_Pole" klasy "KlasaA" nie bedzie dostepne z poziomu
metody klasy pochodnej ("KlasaB")?
NIE
#=========================================================================
Mamy zdefiniowana klase "KlasaA" oraz zdeklarowany jest obiekt Ob:
class KlasaA {
public:
int _Pole;
};
const KlasaA Ob;
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
81.OpisPytania
... powyzsza deklaracja obiektu 'Ob' bylaby poprawna, gdyby
w klasie zostal zadeklarowany konstruktor bezparametryczny,
np.
class KlasaA {
public:
int _Pole;
KlasaA() {}
};
TAK
82.OpisPytania
... obiekt nie jest inicjalizowany, tak wiec nie moze byc
zadeklarowany jako staly.
TAK
83.OpisPytania
... powyzsza deklaracja obiektu 'Ob' bylaby poprawna, gdyby
w klasie zostal zadeklarowany konstruktor postaci:
class KlasaA {
public:
int _Pole;
KlasaA(int Wartosc) { _Pole = Wartosc; }
};
NIE. Musiałoby być const KlasaA Ob(30)
84.OpisPytania
... powyzsza deklaracja obiektu 'Ob' bylaby poprawna, gdyby
pole '_Pole' zostalo zadeklarowane jako statyczne,
tzn.:
class KlasaA {
public:
static int _Pole;
};
NIE
85.OpisPytania
... powyzsza deklaracja bylaby poprawna jesli odpowiednia instrukcja
zainicjalizuje obiekt po jego utworzeniu zgodnie ze schematem:
KlasaA Ob;
jakas_instrukcja_inicjalizujaca_obiekt_Ob;
gdzie za napis "jakas_instrukcja_inicjalizujaca_obiekt_Ob" trzeba
podstawic odpowiednia instrukcje lub ciag instrukcji.
NIE, chyba
#=========================================================================
OpisProblemu
Mamy zdefiniowana klase "KlasaA" oraz zdeklarowany jest obiekt Ob:
class KlasaA {
public:
int _Pole;
static int _PoleStatyczne;
KlasaA() {}
};
int KlasaA::_PoleStatyczne = 0;
int main()
{
const KlasaA Ob;
Ob._Pole = 1;
Ob._PoleStatyczne = 4;
}
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
86.OpisPytania
... ze wzgledu na to, iz obiekt 'Ob' jest zadeklarowny jako staly,
to obie operacje przypisania w funkcji 'main' sa niepoprawne.
NIE
87.OpisPytania
... obie operacje przypisania w funkcji "main" mozna zrealizowac
pod warunkiem wykonania rzutowania za pomoca operatora static_cast.
NIE
88.OpisPytania
... operacja zmiany wartosci pola statycznego moze byc wykonana
zawsze niezaleznie od tego czy obiekt jest staly czy nie.
Jedynym warunkiem jest dostepnosc tego pola.
TAK
#=========================================================================
Mamy zdefiniowana klase "KlasaX":
class KlasaX {
public:
int _Pole;
};
Czy prawda jest, ze ...
#-------------------------------------------------------------------------
89.OpisPytania
... w klasie tej istnieje tylko jeden domyslny konstruktor.
Jest nim konstruktor bezparametryczny.
NIE (istnieje też kopiujący)
90.OpisPytania
... w klasie tej istnieja co najmniej trzy domyslne konstruktory.
Chyba NIE (jak wiem, że istnieje bezparametryczny i kopiujący, jak ktoś zna inne proszę krzyczeć)
91.OpisPytania
... w klasie tej istnieja co najmniej dwa domyslne konstruktory.
TAK (bezparametryczny i kopiujący)
92.OpisPytania
... w klasie tej istnieje konstruktor bezparametryczny.
TAK (coś takiego: KlasaX obiekt; się skompiluje, więc musi istnieć bezparametryczny domyślny; KlasaX ob1; ob1 = KlasaX(); też się kompiluje)
#=========================================================================
Mamy zdefiniowana klase "KlasaA":
class KlasaA {
public:
int _Pole;
};
Czy prawda jest, ze ...
93.OpisPytania
... w tej klasie nie ma zdefiniowanego zadnego konstruktora,
z tego powodu nie ma rowniez konstruktorow domyslnych.
NIE (Istnieje np. konstruktor bezparametryczny, tyle ze produkuje „śmieci” w polu _Pole)
94.OpisPytania
... w tej klasie istnieja co najmniej trzy konstruktory domyslne.
95.OpisPytania
... w tej klasie istnieje konstruktor domyslny odpowiedzialny za
kopiowanie obiektu.
TAK (mając ob1 i ob2 da się wykonać ob2=ob1; )
96.OpisPytania
... mozna utworzyc obiekt tej klasy wywolujac konstruktor
bezparametryczny.
Chyba TAK (działa coś takiego KlasaA ob1; ob1 = KlasaA(); - jawnie wywołaliśmy konstruktor bezparametryczny)
#=========================================================================
Mamy zdefiniowana klase "FiguraGeom":
class FiguraGeom {
public:
double _Obwod;
FiguraGeom(): _Obwod() {}
};
Czy prawda jest, ze ...
97.OpisPytania
... w tej klasie zdefiniowanie konstruktora bezparametrycznego powoduje
uniewaznienie domyslnego konstruktora kopiujacego.
NIE (jak nie zdefiniujemy konstruktora bezparametrycznego, to i tak będziemy mieli domyślny konstruktor kopiujący)
98.OpisPytania
... w tej klasie po utworzeniu obiektu jego pole "_Obwod" bedzie
ono mialo zawsze wartosc 0, o ile zostanie uzyty konstruktor
bezparametryczny. W innym przypadku juz tak byc nie musi.
TAK (znów wredne - możemy zainicjować używając konstruktora kopijącego i wtedy będzie _Obwód będzie miała tę samą wartość, jak to z obiektu z którego kopiowaliśmy)
99.OpisPytania
... w tej klasie po utworzeniu obiektu jego pole "_Obwod" bedzie ono mialo
wartosc 0 po kazdorazowym utworzeniu obiektu z wykorzystaniem konstruktora
bezparametrycznego.
TAK (bo _Obwod inicjujemy domyślnym konstruktorem dla float )
100.OpisPytania
... w tej klasie oprocz zdefiniowanego konstruktora bezparametrycznego
istnieja jeszcze co najmniej dwa domyslne konstruktory.
Chyba NIE (tzn na pewno istnieje kopiujący, a poza tym żadnych innych domyślnych nie znam)
#=========================================================================
Niech bedzie dana definicja klasy:
struct LiczbaZespolona {
float _Re, _Im;
public:
float Re() const { return _Re; }
float& Re() { return _Re; }
float Im() const { return _Im; }
float& Im() { return _Im; }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
101.OpisPytania
... metody "Re()" oraz "Im()" nie sa przeciazone, gdyz zwracaja rozny typ
wartosci.
NIE (klasy-metody.pdf s.75 - przeciążone funkcje różnią się ilością i typem parametrów. „Mogą (lecz nie muszą” zwracać wartości różnego typu ))
102.OpisPytania
... niezaleznie od sposobu utworznia obiektu tej klasy nie mozna
zmienic jego zawartosci.
NIE (podchwytliwe :P to jest struci, nie class, więc domyślnie _re i _im są public - mamy pełen dostęp)
103.OpisPytania
... dla kodu przedstawionego ponizej zostanie wywolana metoda
"float LiczbaZespolona::Re() const".
float Odczyt(LiczbaZespolona& Z)
{
cout << Z.Re();
}
NIE (bo argumentem funkcji jest referencja do obiektu)
104.OpisPytania
... w funkcji ponizej tworzy sie obiekt staly, ktory jest inicjalizowany
wartoscia parametru wywolania tej funkcji.
float Odczyt(const LiczbaZespolona Z)
{
cout << Z.Re();
}
TAK (Uruchamia się konstruktor kopiujący, kopiuje Z, używa go w sunkcji i kasuje)
#=========================================================================
105.OpisProblemu
Niech bedzie dana definicja klasy oraz zapowiedz definicji funkcji:
class KlasaLiczby {
float _Liczba;
public:
float PobierzLiczbe() const { return _Liczba; }
float& PobierzLiczbe() { return _Liczba; }
};
void Dzialaj(const KlasaLiczby Lx);
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
106.OpisPytania
... dla wywolania:
int main()
{
KlasaLiczby Li;
Dzialaj(Li);
}
Zawartosc obiektu "Li" na pewno nie ulegnie zmianie, gdyz w zapowiedzi
definicji funkcji znajduje sie modyfikator "const". Bez niego nie ma
juz takiej gwarancji
NIE (Przekazujemy przez wartość, więc fukcja Dzialaj działa na kopi Li, const mówi tylko, że ta kopia wewnątrz fukcji się nie zmieni)
107.OpisPytania
... dla wywolania:
int main()
{
KlasaLiczby Li;
Dzialaj(Li);
}
Zawartosc obiektu "Li" na pewno nie ulegnie zmianie, gdyz obiek przkazywany
jest do funkcji poprzez wartosc.
TAK (patrz wyżej)
108.OpisPytania
... dla wywolania:
int main()
{
KlasaLiczby Li;
Dzialaj(Li);
}
W trakcie wywolania funkcji obiekt "Li" jest kopiowany.
TAK (patrz pytanie 104)
109.OpisPytania
... dla wywolania:
int main()
{
KlasaLiczby Li;
Dzialaj(Li);
}
Wartosc obiektu "Li" nie ulega zmianie. Ponadto tworzona jest jego kopia,
ktora moze byc modyfikowana wewnatrz funkcji "Dzialaj".
NIE (kopia ta ma modyfikator cons, czyli się nie może zmienić)
#========================================================================
Niech bedzie dana definicja klasy oraz zapowiedz definicji funkcji:
class KlasaLiczby {
float _Liczba;
public:
float PobierzLiczbe() const { return _Liczba; }
float& PobierzLiczbe() { return _Liczba; }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
110.OpisPytania
... rownowazna definicja tej klasy jest:
struct KlasaLiczby {
float _Liczba;
private:
float PobierzLiczbe() const { return _Liczba; }
float& PobierzLiczbe() { return _Liczba; }
};
NIE (dla struct domyślnie jest public, a dla class private)
111.OpisPytania
... rownowazna definicja tej klasy jest:
struct KlasaLiczby {
float PobierzLiczbe() const { return _Liczba; }
private:
float _Liczba;
public:
float& PobierzLiczbe() { return _Liczba; }
};
TAK (patrz poprzednie)
112.OpisPytania
... rownowazna definicja tej klasy jest:
class KlasaLiczby {
public:
float PobierzLiczbe() const { return _Liczba; }
float& PobierzLiczbe() { return _Liczba; }
private:
float _Liczba;
};
TAK (Patrz poprzednie + kolejności deklaracji pól i metod nie ma znaczenia)
113.OpisPytania
... rownowazna definicja tej klasy jest:
struct KlasaLiczby {
float PobierzLiczbe() const { return _Liczba; }
float& PobierzLiczbe() { return _Liczba; }
float _Liczba;
};
NIE (patrz poprzednie - wszystko jest public)
#==== sekcja private i protected ========================================
Niech bedzie dana definicja klasy
class Wektor {
protected:
float _x, _y;
public:
Wektor(float x, float y) { _x = x; _y = y; }
Wektor Dodaj(const Wektor& W) const;
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
114.OpisPytania
... jedna z roznic miedzy sekcja "private", a "protected" polega na tym,
ze w przypadku wystapienia w definicji klasy Wektor sekcji "private"
zamiast "protected" ponizsza definicja metody nie zawsze bylaby poprawna:
Wektor Wektor::Dodaj(const Wektor& W) const
{
return Wektor(_x + W._x, _y + W._y);
}
NIE (różnica między private a protected wychodzi przy okazji dziedziczenia )
115.OpisPytania
... rownowazna definicja klasy "Wektor" jest:
class Wektor {
float _x, _y;
public:
Wektor(float x, float y) { _x = x; _y = y; }
Wektor Dodaj(const Wektor& W) const;
};
NIE (ponieważ _x i_y są tutaj private, jakbyśmy dziedziczyli tę klasę to jest to różnica)
116.OpisPytania
... w definicji metody "Dodaj", przedstawionej ponizej, mozna
odwolywac sie do pol chronionych innych obiektow tej samej klasy.
Jest to prawdziwe dla dowolnej metody, ktora zdefiniowana bylaby
dla klasy "Wektor".
Wektor Wektor::Dodaj(const Wektor& W) const
{
return Wektor(_x + W._x, _y + W._y);
}
117.OpisPytania
... sekcja "protected" nie ma zadnego znaczenia, gdy w metodach
odwolujemy sie do pol, ktore wraz z metodami sa elementami definicji
tej samej klasy. Przykladem moze byc odwolanie sie do pol prywatnych
"_x" i "_y" w konstruktorze klasy "Wektor".
TAK (jak w pytaniu 114 - patrz s.266 Symfonii C++)
#=========================================================================
OpisProblemu
Niech bedzie dana definicja klasy i deklaracja pola statycznego:
class KlasaLiczby {
protected:
static int _IloscLiczb;
public:
float _Liczba;
KlasaLiczby(): _Liczba() { ++_IloscLiczb; }
~KlasaLiczby() { --_IloscLiczb; }
};
int KlasaLiczby::_IloscLiczb;
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
118.OpisPytania
... po utworzeniu obiektu klasy "KlasaLiczby" pola "_IloscLiczb"
i "_Liczba" beda mialy zawsze rozne wartosci.
TAK (_Liczba ma wartość 0 - domyślny konstruktor float, a _IloscLiczb jest inicjowane na 0 - symysln konstruktor int i zwiekszane o 1 przy każdym tworzeniu ob. Klasy KlasaLiczb, ponieważ jest static, to jest wspólny dla wszystkich obiektów tej klasy)
119.OpisPytania
... dodanie nowego pola statycznego moze prowadzic do zwiekszenia
rozmiaru obiektu.
NIE (nowe pole statyczne nie należy do żadnego obiektu z osobna - jest wpólne. Symfonia C++ s.295)
120.OpisPytania
... w konstruktorze nie jest inicjalizowane pole "_Liczba". Moze
wiec sie zdarzyc, ze jego wartosc po utworzeniu obiektu bedzie dowolna.
Aczkolwiek zazwyczaj bedzie to wartosc 0.
NIE (_Liczba() jest jawnym wywołaniem konstruktora float inicjalizującego na 0)
130.OpisPytania
... w tym przypadku pole statyczne "_IloscLiczb" jest niejawnie
inicjalizowane ta sama wartoscia jak pole "_Liczba".
chyba TAK (Podchwytliwe, bo inicjalizacja _IloscLiczb ma miejsce w int KlasaLiczby::_IloscLiczb; i rzeczywiscie jest tu niejawnie wywołany konstruktor int ustawiający to pole na 0, a pole _Liczba też jest zawsze ustawiane na 0 jawnym wywołaniem konstruktora)
#=========================================================================
Niech bedzie dana definicja klas i zapowiedz definicji funkcji:
class FiguraGeometryczna {
protected:
float _WsplrzednaSrodka_x, _WsplrzednaSrodka_y;
};
class Kwadrat: public FiguraGeometryczna {
public:
float _RozmiarBoku;
};
void Dzialaj( FiguraGeometryczna Fig );
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
131.OpisPytania
... wywolanie funkcji przedstawione ponizej
int main()
{
Kwadrat Kw;
Dzialaj(Kw);
}
moze byc nieprawidlowe, choc nie zawsze to zasygnalizuje kompilator.
Powodem sa rozne typy obiektu i parametru formalnego.
NIE
132.OpisPytania
... wywolanie funkcji przedstawione ponizej
int main()
{
Kwadrat Kw;
Dzialaj(Kw);
}
niezaleznie od definicji funkcji "Dzialaj" nigdy nie spowoduje ona
zadnych zmian w obiekcie "Kw".
TAK
133.OpisPytania
... wywolanie funkcji przedstawione ponizej
int main()
{
Kwadrat Kw;
Dzialaj(Kw);
}
do funkcji "Dzialaj" przekazywana jest kopia podobiektu
klasy "FiguraGeomtryczna", ktory zawarty jest w obiekcie "Kw".
TAK
134.OpisPytania
... wywolanie funkcji przedstawione ponizej
int main()
{
Kwadrat Kw;
Dzialaj(Kw);
}
w zaleznosci od definicji funkcji "Dzialaj" mozna odwolac sie
do obiektu "Kw", choc nie bedzie go mozna zmienic.
TAK
#=========================================================================
Niech bedzie dana definicja klas i zapowiedz definicji funkcji:
class Liczba {
public:
Liczba() { _wLiczba = new float; }
~Liczba() { delete _wLiczba; }
Liczba& operator = (const Liczba& L);
private:
float *_wLiczba;
};
Liczba& Liczba::operator = (const Liczba& L)
{
*_wLiczba = *L._wLiczba;
return *this;
}
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
135.OpisPytania
... dla kodu przedstawionego ponizej
int main()
{
Liczba L1;
Liczba L2 = L1;
}
operacja przypisania wartosci L1 do L2 zostanie wykonana poprawnie
dzieki przeciazeniu operatora "=". Niemniej uzycie niektorych
kompilatorow, moze powodowac bledne wykonanie programu.
TAK, chociaż nie jestem pewien co do ostatniego zdania
136.OpisPytania
... dla kodu przedstawionego ponizej
int main()
{
Liczba *wL = new Liczba;
Liczba L1 = *wL;
}
operacja tworzenia obiektu L1 nie wykorzystuje konstruktora
bezparametrycznego, ani tez przeciazenia operatora "=".
NIE
137.OpisPytania
... dla kodu przedstawionego ponizej
int main()
{
Liczba *wL = new Liczba;
Liczba L1 = *wL;
}
przedstawiona konstrukcja jest prawidlowa i destrukcja obiektow
przebiegnie bez zadnych bledow. Byloby jednak lepiej, aby jawnie
usuwac obiekt *wL poprzez uzycie operatora "delete", tzn.
delete wL;
NIE
138. OpisPytania
... konstrukcja klasy nie zapewnia poprawnego dzialania
programu w przypadku poslugiwania sie funkcjami z parametrami
klasy "Liczba" przekazywanymi przez wartosc, np.
void Dzialaj( Liczba L )
{
...
}
TAK (brak konstruktora kopiującego)
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
class Klasa {
int _Kod;
public:
const Klasa& Metoda1() const { return *this; }
Klasa& Metoda2() { return *this; }
const Klasa& Metoda3() { return *this; }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
139.OpisPytania
... ze ponizszy ciag wywolan
int main()
{
Klasa Ob;
Ob.Metoda1().Metoda2().Metoda3();
}
jest niepoprawny, gdyz metode mozna wywolywac tylko dla
obiektu, a nie wyniku zwracanego przez inna metode.
NIE
#-----------------------------------------------------------------------
140.OpisPytania
... ze ponizszy ciag wywolan
int main()
{
Klasa Ob1;
const Klasa Ob2;
Ob2 = Ob1.Metoda2();
}
doprowadzi do sytuacji, ze zmiennej "Ob2" znajdzie sie obiekt,
ktory bedzie modyfikowalny.
NIE
#-----------------------------------------------------------------------
141.OpisPytania
... ze dla ponizszego ciagu wywolan
int main()
{
Klasa Ob;
const Klasa &Ref_Ob = Ob;
Ref_Ob.Metoda1();
Ob.Metoda2();
}
zarowno "Metoda1" jak tez "Metoda2" zwraca referencje do tego samego
obiektu.
TAK
#-----------------------------------------------------------------------
141.OpisPytania
... ze dla ponizszego ciagu wywolan
int main()
{
Klasa Ob1;
Klasa Ob2;
Ob1.Metoda2() = Ob2.Metoda1();
}
po wykonaniu tej operacji zawartosc obu obiektow bedzie jednakowa.
TAK
#-----------------------------------------------------------------------
142.OpisPytania
... ze dla ponizszego ciagu wywolan
int main()
{
Klasa Ob1;
Klasa Ob2;
Ob2.Metoda1() = Ob1.Metoda2();
}
po wykonaniu tej operacji zawartosc obu obiektow bedzie jednakowa.
NIE
#-----------------------------------------------------------------------
143.OpisPytania
... ze ponizszy ciag wywolan
int main()
{
Klasa Ob;
Ob.Metoda1().Metoda2().Metoda3();
}
jest niepoprawny, gdyz metode modyfikujaca obiekt
mozna wywolywac tylko dla obiektu modyfikowalnego.
CHYBA TAK
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
int main()
{
try {
throw std::cout;
}
catch (std::ostream& OStrm) {
cout << "Obsluga: 1" << endl;
}
catch (std::istream& OStrm) {
cout << "Obsluga: 2" << endl;
}
}
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
144.OpisPytania
... zapis jest niepoprawny, gdyz nie mozna zglaszac jako wyjatkow
obiektow z biblioteki standardowej.
NIE
#-----------------------------------------------------------------------
145.OpisPytania
... zapis jest niepoprawny, gdyz strumieni nie mozna przekazywac
do metod poprzez wartosc.
TAK
#-----------------------------------------------------------------------
146.OpisPytania
... zapis jest niepoprawny, gdyz jako wyjatku nie mozna zglaszac
w jakiejkolwiek formie strumienia standardowego, tzn. bezposrednio
jako obiekt lub posrednio poprzez zmienne referencjna lub wskaznik.
TAK ??
#-----------------------------------------------------------------------
147.OpisPytania
... mozliwa jest modyfikacja zgloszenia obiektu std::cout bez
wprowadzania dodatkowych definicji klas, tak aby ktoras z
istniejacych sekcji "catch" przechwycila go.
??
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
class FiguraGeometryczna {
public:
double _Pole;
};
class Kwadrat: public FiguraGeometryczna {
public:
double _DlugoscBoku;
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
148.OpisPytania
... w przedstawionym ponizej zapisie wystepuje niejawne rzutowanie
"w gore".
int main()
{
Kwadrat Kw;
FiguraGeometryczna *wFig = &Kw;
}
TAK
#-----------------------------------------------------------------------
149.OpisPytania
... w przedstawionym ponizej zapisie wystepuje niejawne rzutowanie
"w dol".
int main()
{
Kwadrat Kw;
FiguraGeometryczna *wFig = &Kw;
}
NIE
#-----------------------------------------------------------------------
150.OpisPytania
... w przedstawionym ponizej zapisie wystepuje niejawne rzutowanie
"w dol".
int main()
{
FiguraGeometryczna Fig;
Kwadrat *wKw = &Fig;
}
TAK
#-----------------------------------------------------------------------
151.OpisPytania
... w przedstawionym ponizej zapisie wystepuje niejawne rzutowanie
"w gore".
int main()
{
FiguraGeometryczna Fig;
Kwadrat *wKw = &Fig;
}
NIE
#-----------------------------------------------------------------------
152.OpisPytania
... w przedstawionym ponizej zapisie poprzez zmienna "Fig" mamy dostep
do podobiektu znawartego w obiekcie "Kw".
int main()
{
Kwadrat Kw;
FiguraGeometryczna &Fig = Kw;
}
TAK
#-----------------------------------------------------------------------
153.OpisPytania
... w przedstawionym ponizej zapisie poprzez zmienna "Fig" mamy dostep
do podobiektu zawartego w obiekcie "Kw". Pozwala to modyfikowac zawartosc
obiektu "Kw" poprzez zmiany w obiekcie "Fig".
int main()
{
Kwadrat Kw;
FiguraGeometryczna Fig = Kw;
}
NIE
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
class FiguraGeometryczna {
public:
double _Pole;
double ObliczPole() { return _Pole; }
};
class Kwadrat: public FiguraGeometryczna {
public:
double _DlugoscBoku;
double ObliczPole(double Skala)
{ return pow(Skala*_DlugoscBoku,2); }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
154.OpisPytania
... ponizszy zapis jest nieprawidlowy i nie ma sposobu, aby
nie modyfikujac definicji klas i dysponujac obiektem "Kw"
odwolac sie do metody "ObliczPole()" z klasy "FiguraGeometryczna".
int main()
{
Kwadrat Kw;
Kw.ObliczPole();
}
NIE (można się odwołać do metody z FG)
#-----------------------------------------------------------------------
155.OpisPytania
... ponizszy zapis jest nieprawidlowy. Dysponujac referencja "Fig" do
obiektu klasy "FiguraGeometryczna" i nie dokonujac zadnych
rzutowan mozna odwolac sie tylko do metody "ObliczPole()",
a nie "ObliczPole(double)".
int main()
{
Kwadrat Kw;
FiguraGeometryczna &Fig = Kw;
Fig.ObliczPole(1.0);
}
TAK
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
class FiguraGeometryczna {
double _Pole;
public:
double ObliczPole() { return _Pole; }
};
class Kwadrat: private FiguraGeometryczna {
double _DlugoscBoku;
public:
double ObliczPole(double Skala)
{ return pow(Skala*_DlugoscBoku,2); }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
156.OpisPytania
... ponizszy zapis jest nieprawidlowy i nie ma sposobu, aby
dysponujac obiektem "Kw" odwolac sie do metody "ObliczPole()"
z klasy "FiguraGeometryczna".
int main()
{
Kwadrat Kw;
Kw.ObliczPole();
}
TAK
#-----------------------------------------------------------------------
157.OpisPytania
... ponizszy zapis jest nieprawidlowy, chociaz rzutowanie niejawne
na referencje do podobiektu klasy "FiguraGeometryczna" jest poprawne.
int main()
{
Kwadrat Kw;
FiguraGeometryczna &Fig = Kw;
Fig.ObliczPole();
}
TAK
#-----------------------------------------------------------------------
158.OpisPytania
... ponizszy zapis jest nieprawidlowy. Jednym z powodow jest to, ze
ze wzgledu na dziedziczenie, gdy dysponujemy referencja "Fig"
mozemy odwolac sie tylko do metody "ObliczPole(double)".
int main()
{
Kwadrat Kw;
FiguraGeometryczna &Fig = Kw;
Fig.ObliczPole();
}
TAK
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
class FiguraGeometryczna {
double _Pole;
double ObliczPole() { return _Pole; }
public:
};
class Kwadrat: public FiguraGeometryczna {
double _DlugoscBoku;
public:
double ObliczPole(double Skala)
{ return pow(Skala*_DlugoscBoku,2); }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
159.OpisPytania
... ponizszy zapis jest nieprawidlowy i nie ma sposobu, aby
dysponujac obiektem klasy "Kwadrat" odwolac sie do
metody "ObliczPole()" z klasy "FiguraGeometryczna".
int main()
{
Kwadrat Kw;
Kw.ObliczPole();
}
NIE (można się odwołać)
#-----------------------------------------------------------------------
160.OpisPytania
... ponizszy zapis jest nieprawidlowy. Dysponujac referencja "Fig" do
obiektu klasy "FiguraGeometryczna" i dokonujac rzutowan mozna
odwolac sie tylko do metody "ObliczPole(double)", a nie "ObliczPole()".
int main()
{
Kwadrat Kw;
FiguraGeometryczna &Fig = Kw;
Fig.ObliczPole();
}
NIE
#-----------------------------------------------------------------------
161.OpisPytania
... ponizszy zapis jest nieprawidlowy. Dysponujac referencja do
obiektu klasy "FiguraGeometryczna" i nie dokonujac zadnych
rzutowan mozna odwolac sie tylko do metody "ObliczPole()",
a nie "ObliczPole(double)".
int main()
{
Kwadrat Kw;
FiguraGeometryczna &Fig = Kw;
Fig.ObliczPole(1.0);
}
NIE
#=========================================================================
162.OpisProblemu
Niech beda dane prototypy dwoch funkcji:
void Wylicz( float Param1, double Param2 );
void Wylicz( double Param1, float Param2 );
Zakladajac, ze w programie znajduja sie poprawne ich definicje
i ze nie ma innego przeciazenia funcji "Wylicz",
czy prawda jest, ze ...
#-----------------------------------------------------------------------
163.OpisPytania
... w funkcji main przedstawionej ponizej:
int main()
{
Wylicz(1.2, 'c');
}
na ogol zostanie wywolana druga z przedstawionych funkcji,
tzn. Wylicz( double Param1, float Param2 );
Zalezy to jednak od kompilatora i od domyslnej interpretacji
uzytej w liscie parametrow stalej liczbowej.
TAK
164.OpisPytania
... w funkcji main przedstawionej ponizej:
enum PoryRoku { Wiosna, Lato, Jesien, Zima };
int main()
{
Wylicz( Wiosna , 1.2);
}
zostanie wywolana pierwsza z przedstawionych funkcji,
tzn. Wylicz( float Param1, double Param2 );
O wywolaniu tej funkcji decyduje uzyta stala liczbowa.
TAK
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
class FiguraGeometryczna {
double _PolePowierzchni;
public:
double& UzyjPole() { return _PolePowierzchni; }
};
class Kwadrat: public FiguraGeometryczna {
double _DlugoscBoku;
public:
Kwadrat& ZmienDlugosc(double Dl) { _DlugoscBoku = Dl; return *this; }
FiguraGeometryczna& UzyjFigure() { return *this; }
};
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
165.OpisPytania
... przedstawiony ponizej kod programu jest poprawny i nigdy
nie spowoduje bledu wykonania programu (np. niedozwolony dostep
do pamieci).
int main()
{
Kwadrat Kw;
FiguraGeometryczna Fig;
Kw.ZmienDlugosc(10).UzyjFigure().UzyjPole() = 5;
}
TAK
#-----------------------------------------------------------------------
166.OpisPytania
... przedstawiony ponizej kod programu jest poprawny i nigdy
nie spowoduje bledu wykonania programu (np. niedozwolony dostep
do pamieci).
int main()
{
Kwadrat Kw;
FiguraGeometryczna Fig;
Kw.ZmienDlugosc(10).UzyjPole().UzyjFigure() = 5;
}
NIE
#-----------------------------------------------------------------------
167.OpisPytania
... przedstawiony ponizej kod programu moze (ale nie musi)
spowodowac zmiane zawartosci obiektu "Fig".
int main()
{
Kwadrat Kw;
FiguraGeometryczna Fig;
Kw.ZmienDlugosc(10).UzyjFigure().UzyjPole() = 5;
}
NIE
#-----------------------------------------------------------------------
168.OpisPytania
... przedstawiony ponizej kod programu nigdy nie spowoduje zmiany
zawartosci obiektu "Fig".
int main()
{
Kwadrat Kw;
FiguraGeometryczna Fig;
Kw.ZmienDlugosc(10).UzyjFigure().UzyjPole() = 5;
}
KoniecOpisu
TAK
#=========================================================================
Niech bedzie dany nastepujacy fragment kodu
#include <iostream>
#include <string>
#include <cctype>
#include <cmath>
int main()
{
}
Czy prawda jest, ze ...
#-----------------------------------------------------------------------
169.OpisPytania
... zapis #include <cmath> powoduje, ze do programu dolaczany jest
plik naglowkowy "cmath", ktory NIE moze byc uzyty w przypadku programow
pisanych w jezyku C.
NIE
#-----------------------------------------------------------------------
170.OpisPytania
... zapis #include <cmath> powoduje, ze do programu zawsze dolaczany
jest plik naglowkowy "math.h"
KoniecOpisu
CHYBA TAK
#-----------------------------------------------------------------------
171.OpisPytania
... zapis #include <cctype> odpowiada dolaczeniu pliku "type.h"
gdy program pisany jest w jezyku C. Charakterystyczna cecha nazw
odpowiednikow plikow z jezyka C jest dolaczenie na poczatku dwoch
literek 'c'.
NIE
#-----------------------------------------------------------------------
172.OpisPytania
... zapis #include <string> odpowiada dolaczeniu pliku "string".
Plik ten NIE jest odpowiednikiem pliku naglowkowego "string.h"
stosowanego w programach pisanych w jezyku C.
KoniecOpisu
CHYBA TAK