Test Napisz co pojawi się na ekranie

Transkrypt

Języki i paradygmaty programowania
Przykładowe typy zadań
Test
1. Dana jest klasa
class Podstawowa { };
Dziedziczenie publiczne zostało zdefiniowane w:
[ ] (A) class Pochodna : private Podstawowa { };
[ ] (B) class Pochodna : public Podstawowa { };
[ ] (C) class Pochodna : Podstawowa { };
2. Jaka jest kolejność wywołania konstruktorów dla obiektu d klasy D, jeśli dana jest następująca
hierarchia klas:
class A { };
class B : public A { };
class C : public A { };
class D : public C { };
[ ] (A) A B C D
[ ] (B) A C D
[ ] (C) D C A
3. Jaka jest kolejność zakończenia pracy przez konstruktory dla obiektu d klasy D, jeśli dana jest
następująca hierarchia klas:
class A { };
class B : public A { };
class C : public A { };
class D : public C { };
[ ] (A) A B C D
[ ] (B) A C D
[ ] (C) D C A
4. Uwzględniając hierarchię klas z pytania powyŜszego, ustal, w jakiej kolejności są wywoływane
destruktory obiektu d klasy D.
[ ] (A) A C D
[ ] (B) D C A
[ ] (C) A B C D
5. Dana jest hierarchia klas
class X { };
class A : public X { };
class Y : public A { };
class B : private A { };
Która z poniŜszych linii jest błędna?
[ ] (A) X *wsk=new B;
[ ] (B) A *wsk=new Y;
[ ] (C) X *wsk=new Y;
6. Deklarację metod wirtualnych w klasie zaczynamy słowem kluczowym:
[ ] (A) virtual
[ ] (B) namespace
[ ] (C) template
7. Domyślny sposób dziedziczenia to dziedziczenie:
[ ] (A) publiczne
[ ] (B) chronione
[ ] (C) prywatne
8. Jaką etykietą jest poprzedzona sekcja klasy, z której elementów nie moŜne korzystać program
zewnętrzny, natomiast mogą korzystać klasy pochodne?
[ ] (A) private
[ ] (B) public
[ ] (C) protected
1
9. Dane są następujące definicje:
class A {public: void wypisz ( ) { } };
class B : public A {public: void wypisz ( ) { } };
B b;
Metodę wypisz z klasy A na rzecz obiektu b moŜna wywołać w następujący sposób:
[ ] (A) b.wypisz( );
[ ] (B) b.A::wypisz( );
[ ] (C) metody wypisz z klasy A na rzecz obiektu b nie moŜna wywołać
10. Zaznacz poprawne stwierdzenie.
[ ] (A) Konstruktory klasy są dziedziczone
[ ] (B) Konstruktory klasy nie są dziedziczone
[ ] (C) Dziedziczenie konstruktorów zaleŜy od tego, w której części klasy podstawowej zostały
zdefiniowane
11. Dane są
namespace A
{ void wypisz ( ) {cout<<"*";} }
namespace B
{ void wypisz ( ) {cout<<"?";} }
using namespace A;
Co pojawi się na ekranie po następującym wywołaniu
wypisz( );
[ ] (A) ?
[ ] (B) *
[ ] (C) powyŜsza linia wygeneruje błąd dwuznaczności
12. Klasa podstawowa powinna zawierać
[ ] (A) konstruktor wirtualny
[ ] (B) destruktor wirtualny
[ ] (C) tylko metody wirtualne
13. Czysto wirtualny destruktor
[ ] (A) musi być zdefiniowany w klasach pochodnych
[ ] (B) nie musi być zdefiniowany w klasach pochodnych
[ ] (C) nie musi być zdefiniowany w klasie podstawowej tak jak inne metody czysto wirtualne
14. PoniŜsza deklaracja:
template <class Typ> class Prostokat;
jest:
[ ] (A) deklaracją szablonu funkcji
[ ] (B) deklaracją szablonu klasy
[ ] (C) błędna
15. Dane są :
template <class T> T suma(T arg1, T arg2) {return arg1+arg2;}
double S=suma<int>(12.7, 13.8) ;
Zmienna S ma wartość :
[ ] (A) 26.5
[ ] (B) 26
[ ] (C) 25
Napisz co pojawi się na ekranie
Zadanie 1.
Co pojawi się na ekranie po wykonaniu następujących linii kodu?
#include <iostream>
using std::cout;
class X
{
2
protected:
int b;
public:
X(int x):b(x) {cout<<"konstruktor X\n";}
~X() {cout<<b<<"destruktor X\n";}
void metoda(int a) {b=a;}
};
class Y:public X //Jak zamiana public na private wpłynie na kod?
{
protected:
int a;
public:
Y(int x,int y):X(x),a(y) {cout<<"konstruktor Y\n";}
~Y() {cout<<a<<" "<<b<<"destruktor Y\n";}
};
int main()
{
X a(23);
Y b(2,4);
a.metoda(9);
b.metoda(12);
return 0;
}
Zadanie 2.
Napisz, co pojawi się na ekranie po wykonaniu następujących linii kodu?
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
~X() {cout<<b<<"destruktor X\n";}
};
{
protected:
int a;
public:
Y(int x,int y):X(x),a(y) {cout<<"konstruktor Y\n";}
};
int main()
{
X *a=new X(23);
X *b=new Y(2,4);
a->metoda(9);
b->metoda(12);
delete a;
delete b;
return 0;
}
Zadanie 3.
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
virtual ~X() {cout<<b<<"destruktor X\n";}
};
class Y:public X //Jak zamiana public na protected wpłynie na kod?
{
protected:
int a;
public:
Y(int x, int y):X(x), a(y) {cout<<"konstruktor Y\n";}
};
int main()
{
X *a=new X(23);
X *b=new Y(2, 4);
a->metoda(9);
b->metoda(12);
delete a;
delete b;
return 0;
}
Zadanie 4.
#include <iostream>
using std::cout;
class X
{
protected: //Jak zamiana protected na private wpłynie na kod?
int b;
public:
X(int x=8):b(-x) {cout<<"konstruktor X\n";}
~X() {cout<<"destruktor X\n";}
void wypisz() const {cout<<b<<"\n";}
};
class Y:public X
{
protected:
int a;
3
4
public:
~Y() {cout<<"destruktor Y\n";}
void wypisz() const {cout<<a<<" "<<b<<"\n";}
};
class YY:public X
{};
int main()
{
X *a=new X(23);
Y *b=new Y(2, 4);
YY *c=new YY;
a->wypisz();
b->wypisz();
c->wypisz();
delete a;
delete b;
delete c;
return 0;
}
Zadanie 5.
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
X(int x=8):b(-x) {cout<<"konstruktor X\n";} //Co się stanie, gdy zrezygnujemy z wartości domyślnej?
};
class Y:public X
{
protected:
int a;
public:
};
class YY:public X
{};
int main()
{
X *a=new X(23);
X *b=new Y(2, 4);
X *c=new YY;
a->wypisz();
b->wypisz();
5
c->wypisz();
delete a;
delete b;
delete c;
return 0;
}
Zadanie 6.
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
virtual ~X() {cout<<"destruktor X\n";}
virtual void wypisz() const {cout<<b<<"\n";} //Uczyń z metody wypisz metodę czysto wirtualną oraz
// wprowadź niezbędne zmiany w programie
};
class Y:public X
{
protected:
int a;
public:
};
class YY:public X
{};
int main()
{
X *a=new X(23);
X *b=new Y(2, 4);
X *c=new YY;
a->wypisz();
b->wypisz();
c->wypisz();
delete a;
delete b;
delete c;
return 0;
}
Zadanie 7.
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
6
};
{};
void wywolaj(const X& arg)
{arg.wypisz(); }
class Y:public X
{
protected:
int a;
public:
Y(int x, int y):X(x), a(y) {cout<<"konstruktor Y\n";} // Czy moŜna w tej linii opuścić jawne wywołanie
// konstruktora klasy X? Dlaczego?
};
class YY:public X
{};
{arg.wypisz(); }
int main()
{
X *a[3]={new X(23), new Y(2, 4), new YY};
for (int i=0;i<3;++i) wywolaj(*a[i]);
for (int i=0;i<3;++i) delete a[i];
return 0;
}
Zadanie 8.
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
virtual void wypisz() const {cout<<b<<"\n";}
};
class Y:public X
{
protected:
int a;
public:
};
class YY:public X
7
int main()
{
X *a[3]={new X(23), new Y(2, 4), new YY};// Czy w przypadku abstrakcyjnej klasy X linia ta byłaby
// poprawna?
return 0;
}
Zadanie 9.
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
};
class Y:public X
{
protected:
int a;
public:
Y(int x, int y):X(x), a(y) {cout<<"konstruktor Y+\n";}
};
class YY:public X
{};
void wywolaj(const X arg)
{arg.wypisz(); }
int main()
{
return 0;
}
Zadanie 10. Co pojawi się na ekranie po wykonaniu następujących linii kodu?
#include <iostream>
using std::cout;
class X
8
{
protected:
int b;
public:
X(const X& wzor):b(wzor.b+1){cout<<":-)\n";}
};
Y(const Y& wzor):X(wzor), a(wzor.a-1) {cout<<":-)))\n";}
};
class YY:public X
{};
{arg.wypisz(); }
{
protected:
int a;
public:
void wypisz() {cout<<a<<" "<<b<<"\n";}
};
class YY:public X
{};
{arg.wypisz(); }
int main()
{
return 0;
}
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
X(const X& wzor):b(wzor.b+1) {cout<<":-)\n";} // Czy tu moŜna zrezygnować z referencji?
};
class Y:public X
{
protected:
int a;
public:
9
int main()
{
return 0;
}
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
X(const X& wzor):b(wzor.b+1) {cout<<":-)\n";}
};
class Y:public X
{
protected:
int a;
public:
Y(const Y& wzor):X(wzor), a(wzor.a-1) {cout<<":-)))\n";}
};
class YY:public X
{};
{arg.wypisz(); }
int main()
{
10
return 0;
}
#include <iostream>
using std::cout;
class X
{
protected:
int b;
public:
X(int x=8):b(-x) {cout<<"konstruktor X+\n";}
X(const X& wzor):b(wzor.b) {cout<<":-)\n";}
};
class Y:public X
{
protected:
int a;
public:
Y(const Y& wzor):X(wzor), a(wzor.a) {cout<<":-)))\n";}
};
class YY:public X
{};
{arg.wypisz(); }
void wypisz() const {cout<<b<<endl;}
};
int main()
{
X<int> a(23);
a.wypisz();
a.zmien(9);
a.wypisz();
X<double> b(34.89);
b.wypisz();
b.zmien(12.2);
b.wypisz();
X<std::string> c("metody i narzedzia");
c.wypisz();
c.zmien("paradygmaty");
c.wypisz();
return 0;
}
#include <iostream>
using std::cout;
using std::endl;
template <class Typ>
class X
{
protected:
Typ a;
public:
X(Typ x):a(x) {}
void zmien(Typ x) {a=x;}
void wypisz() const {cout<<b<<endl;}
};
int main()
{
X a[3]={X(23), Y(2, 4), YY()};
for (int i=0;i<3;++i) wywolaj(a[i]);
return 0;
}
#include <iostream>
using std::cout;
using std::endl;
template<class Typ1, class Typ2>
class Y:public X<Typ1>
{
Typ2 b;
public:
Y(Typ1 x, Typ2 y):X<Typ1>(x), b(y) {}
void zmien(Typ2 x) {b=x;}
void wypisz() const { cout<<a<<" "<<b<<endl;}
};
class X
{
private:
Typ b;
public:
X(Typ x):b(x) {}
void zmien(Typ a) {b=a;}
int main()
{
Y<int, double> a(23, 7.9);
a.wypisz();
a.zmien(9.8);
a.wypisz();
a.X<int>::zmien(180);
a.wypisz();
11
12
Y<double, std::string> b(34.89, "metody");
b.wypisz();
b.zmien("as");
b.wypisz();
b.X<double>::zmien(123.67);
b.wypisz();
return 0;
}
#include <iostream>
using std::cout;
using std::endl;
Typ suma(Typ a, Typ b)
{return a+b; }
int main()
{
cout<<suma(3, 9)<<endl;
cout<<suma(3.5, 9.67)<<endl;
cout<<suma<int>(2.4, 45)<<endl;
cout<<suma<double>(2.4, 45)<<endl;
return 0;
}
#include <iostream>
using std::cout;
using std::endl;
template <class Typ1, class Typ2>
Typ2 suma(Typ1 a, Typ2 b)
{return a+b;
}
int main()
{
cout<<suma(3, 9.9)<<endl;
cout<<suma(3.5, 9)<<endl;
cout<<suma<double>(2.4, 45)<<endl;
cout<<suma<double>(2, 45.9)<<endl;
return 0;
}
#include <iostream>
using std::cout;
using std::endl;
namespace punkt
{ int i=20, j=1, k=-2; }
{
using punkt::i;
++i;
cout<<i<<endl;
++j;
cout<<j<<endl;
using punkt::j;
++j;
cout<<j<<endl;
int k=15;
++k;
cout<<k<<endl;
}
int main( )
{
ruch( );
return 0;
}
#include <iostream>
using std::cout;
using std::endl;
namespace punkt
{ int i=20, j=1, k=-2; }
int j=5;
void ruch( )
{
++j;
cout<<j<<endl;
using namespace punkt;
++i;
cout<<i<<endl;
++::j;
cout<<::j<<endl;
++punkt::j;
cout<<punkt::j<<endl;
int k=15;
++k;
cout<<k<<endl;
++punkt::k;
cout<<punkt::k<<endl;
}
int main( )
{
ruch( );
return 0;
}
int j=5;
#include <iostream>
void ruch( )
13
14
using std::cout;
using std::endl;
class Schowek
{
protected:
void wypisz() {cout<<"Schowek "<<Typ(123.67)<<endl<<"***"<<endl;}
};
template <class T, class P>
class Sekret :public Schowek<P>
{
public:
void pisz() {cout<<"Sekret "<<T(345.98)<<endl; wypisz();}
};
int main( )
{
Sekret<int, double> S; S.pisz( );
Sekret<double, int> SS; SS.pisz( );
Sekret<double, double> SSS; SSS.pisz( );
Sekret<int, int> SSSS; SSSS.pisz( );
return 0;
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
template <class Typ> void wypisz(vector<Typ> &co);
int main( )
{
int tab[10]={3, 9, 20, 56, 3, 454, 45, 787, 4, 90};
vector<int> wek(tab+2, tab+5); wypisz(wek);
wek.push_back(100); wypisz(wek);
vector<int> wek2(wek.begin( ), wek.end( )); wypisz(wek2);
sort(wek2.begin( ), wek2.end( )); wypisz(wek2);
wek2.pop_back( );wypisz(wek2);
wek2.insert(wek2.begin()+5, -100); wypisz(wek2);
wek2.erase(wek2.begin()+1, wek2.begin()+3); wypisz(wek2);
return 0;
}
void wypisz(vector<Typ> &co)
{
if (co.empty( ))
{
cout<<"Brak elementow w kolekcji"<<endl;
return;
}
for (vector<Typ>::iterator it=co.begin( ); it!=co.end( );++it)
cout<<*it<<" ";
15
cout<<endl;
}
Uzupełnij
Zadanie 1.
Zdefiniuj abstrakcyjną klasę Ksztalt o trzech metodach oblicz_pole, oblicz_obwod
oraz rysuj oraz klasy Prostokat, Kwadrat, Trojkat. Wykorzystaj związki zachodzące między
tymi pojęciami w budowaniu hierarchii dziedziczenia. Napisz program testujący działanie tak
zdefiniowanej hierarchii dziedziczenia.
Zadanie 2.
Dodaj do programu elementy, potrzebne do wykonania następujących linii kodu:
int main( )
{
Moja1 a(15);
a.zmien(45);
Moja2 b(7, 78.9);
b.Moja1::wypisz();
b.wypisz();
return 0;
}
Zadanie 3.
Dodaj do programu elementy, potrzebne do wykonania następujących linii kodu:
int main ( )
{
X *A[5]={new X(23), new Y(5, 8), new Z};
for ( int i=0; i<5; ++i)
A[i]->wypisz();
for ( int i=0; i<5; ++i)
delete A[i];
return 0;
}
Zadanie 4.
Zakładając, Ŝe X jest klasą abstrakcyjną. Dodaj do programu elementy, potrzebne
do wykonania następujących linii kodu:
int main ( )
{
X *A[5]={new Y(23), new Y(8), new Z, new Y(23), new Z(7.9)};
for ( int i=0; i<5; ++i)
A[i]->wypisz();
for ( int i=0; i<5; ++i)
delete A[i];
return 0;
}
Zadanie 5.
Na podstawie informacji zamieszczonych poniŜej dodaj do programu elementy,
potrzebne do wykonania następujących linii kodu:
int main()
{
X obj(67);
X *wsk=new W(4.7, 5, 8);
wsk->wypisz();
delete wsk;
return 0;
}
Z::Z(double x, int y) : X(x), b(y) {}
void W::wypisz( ) {Z::wypisz(); cout<<c<<endl;}
void Y::wypisz( ) {cout<<b<<" "<<d<<endl;}
16
Zadanie 6.
Zakładając, Ŝe w klasach znajdują się deklaracje i wszystkie potrzebne etykiety,
natomiast za klasą znajdują się wszystkie niezbędne definicje, uzupełnij wykropkowane linie:
#include <iostream>
class X
{
.................................................................................................................
.................................................................................................................
.................................................................................................................
.................................................................................................................
.................................................................................................................
};
X::X(int x): a(x) {}
.................................................................................................................
{
std::cout<<a<<std::endl;
}
class XX : public X
{
.................................................................................................................
.................................................................................................................
.................................................................................................................
.................................................................................................................
.................................................................................................................
};
void XX::wypisz( ) const
{
X::wypisz( );
cout<<b<<endl;
}
.................................................................................................................
{
.................................................................................................................
.................................................................................................................
.................................................................................................................
.................................................................................................................
};
XXX::XXX(XX x, double y) : XX(x), c(y) {}
int main()
{
X x(10);
XX xx(x, 12.5);
XXX xxx(xx, 9.99);
X *wsk=&xx;
wsk->wypisz();
return 0;
}
17

Test Napisz co pojawi się na ekranie

Transkrypt

Podobne dokumenty

Przetwarzanie tekstu z pliku W pliku tolkien.txt dana jest jedna linia

zadania z pierwszego terminu egzaminu z Technik Programowania

Programowanie strukturalne i obiektowe Pętle Pętle warunkowe do

Czy n jest liczbą pierwszą? Liczba pierwsza, wiadomo, nie ma

Algorytm zachłanny ( ang. greedy algorithm) wykonuje zawsze

Zadania

NARYSUJ PONIŻSZY SCHEMAT BLOKOWY Wpisz `a` Wpisz `b

w standardzie ASCII każdy znak jest kodowany na