Survey Maker Survey Templates Contact Privacy & Security

PA2: demo skillcheck vol3

Create a vibrant and engaging illustration depicting C++ programming concepts, focusing on memory management, with classes, pointers, and dynamic allocation. Include elements like a computer screen displaying code snippets and brain gears representing knowledge and learning.

C++ Memory Management Quiz

Test your knowledge of C++ memory management concepts with this comprehensive quiz! Delve into the intricacies of class inheritance, constructors, destructors, and dynamic memory allocation. Perfect for both budding developers and seasoned programmers looking to sharpen their skills.

Key Features:

55 challenging questions
Multiple choice and text answers
Immediate feedback on your selections

55 Questions14 MinutesCreated by CodingMaster120

1.: Co zobrazí následující kód?

class A
{
public:
A ( int x = 61 ) { m_X = new int (x); }
A ( const A & src ) { m_X = new int ( *src . m_X ); }
virtual ~A ( void ) { delete m_X; }
virtual void print ( void ) const { cout << *m_X; }
private:
int *m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = new int (y); }
B ( const B & src ) : A ( src ) { m_Y = new int (*src.m_Y); }
virtual ~B ( void ) { delete m_Y; }
virtual void print ( void ) const { A::print (); cout << *m_Y; }
private:
int *m_Y;
};

void foo ( A * val )
{
val -> print ( );
delete val;
}

int main ( void )
{
foo ( new B ( 81, 51 ) );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(1.) Zobrazí:

2.: Co zobrazí následující kód?

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
virtual void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A & val )
{
val . print ( );
}

int main ( void )
{
B test ( 39, 44 );
foo ( test );
return 0;
}

Program funguje zcela správně, zobrazí:

Program nepůjde zkompilovat

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje, ale neuvolní alokovanou paměť

(2.) Zobrazí?

3.: Co zobrazí následující kód?

class A
{
public:
A ( int x = 53 ) { m_X = new int (x); }
A ( const A & src ) { m_X = new int ( *src . m_X ); }
~A ( void ) { delete m_X; }
virtual void print ( void ) const { cout << *m_X; }
private:
int *m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = new int (y); }
B ( const B & src ) : A ( src ) { m_Y = new int (*src.m_Y); }
~B ( void ) { delete m_Y; }
virtual void print ( void ) const { A::print (); cout << *m_Y; }
private:
int *m_Y;
};

void foo ( A * val )
{
val -> print ( );
delete val;
}

int main ( void )
{
foo ( new B ( 4, 4 ) );
return 0;
}

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje, ale neuvolní alokovanou paměť

4.: Co zobrazí následující kód?

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
friend ostream & operator << ( ostream & os, const A & x )
{ return os << x . m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
friend ostream & operator << ( ostream & os, const B & x )
{ os << (const A &) x; return os << x . m_Y; }
private:
int m_Y;
};

void foo ( A * val )
{
cout << *val;
}

int main ( void )
{
B test ( 66, 45 );
foo ( & test );
return 0;
}

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje, ale neuvolní alokovanou paměť

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

(4.) Zobrazí?

5.: Co zobrazí následující kód?

class A
{
public:
A ( void ) { cout << *this; }
virtual ~A ( void ) {}
virtual void print ( ostream & os ) const { os << "A:"; }
friend ostream & operator << ( ostream & os, const A & x )
{ x . print ( os ); return os; }
};

class B : public A
{
public:
B ( int x ) { cout << *this; m_X = x; }
virtual void print ( ostream & os ) const { os << "B:" << m_X; }
private:
int m_X;
};

int main ( void )
{
B test ( 36 );
return 0;
}

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

Program nepůjde zkompilovat

Program nespadne, ale výstup není definovaný

6.: Co zobrazí následující kód?

class A
{
public:
A ( int x = 55 ) { m_X = new int (x); }
A ( const A & src ) { m_X = new int ( *src . m_X ); }
virtual ~A ( void ) { delete m_X; }
virtual void print ( void ) const { cout << *m_X; }
private:
int *m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = new int (y); }
B ( const B & src ) { m_Y = new int (*src.m_Y); }
virtual ~B ( void ) { delete m_Y; }
virtual void print ( void ) const { A::print (); cout << *m_Y; }
private:
int *m_Y;
};

void foo ( const B & val )
{
val . print ( );
}

int main ( void )
{
B test ( 69, 34 );
foo ( test );
return 0;
}

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(6.) Zobrazí?

7.: Co zobrazí následující kód?

class A
{
public:
A ( int x ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( B val )
{
val . print ( );
}

int main ( void )
{
B test ( 30, 19 );
foo ( test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

(7.) Zobrazí?

8.: Co zobrazí následující kód?

class A
{
public:
A ( void ) { cout <<"A:"; }
virtual ~A ( void ) {}
void print ( ostream & os ) const = 0;
friend ostream & operator << ( ostream & os, const A & x )
{ x . print ( os ); return os; }
};

class B : public A
{
public:
B ( int x ) : m_X ( x ) { cout << *this; }
void print ( ostream & os ) const { os << "B:" << m_X; }
private:
int m_X;
};

int main ( void )
{
B test ( 60 );
return 0;
}

Program nepůjde zkompilovat

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program nespadne, ale výstup není definovaný

Program funguje, ale neuvolní alokovanou paměť

9.: Co zobrazí následující kód?

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
virtual void print ( ostream & os ) const { os << m_X; }
friend ostream & operator << ( ostream & os, const A & x )
{ x . print ( os ); return os; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( ostream & os ) const { A::print ( os ); os << m_Y;
}

friend ostream & operator << ( ostream & os, const B & x )
{ os << "B:"; x . print ( os ); return os; }
private:
int m_Y;
};

void foo ( B * val )
{
cout << * val;
}

int main ( void )
{
B test ( 14, 22 );
foo ( & test );
return 0;
}

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

(9.) Zobrazí?

10.: Co zobrazí následující kód?

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
virtual void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A val )
{
val . print ( );
}

int main ( void )
{
B test ( 9, 40 );
foo ( test );
return 0;
}

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

11.: Co zobrazí následující kód?

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( ostream & os ) const { A::print ( os ); os << m_Y;
}
friend ostream & operator << ( ostream & os, const B & x )
{ os << "B:"; x . print ( os ); return os; }
private:
int m_Y;
};

void foo ( A * val )
{
cout << *val;
}

int main ( void )
{
B test ( 41, 86 );
foo ( &test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

(11.) Zobrazí?

12.: Co zobrazí následující kód?

class A
{
public:
A ( int x ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( B val )
{
val . print ( );
}

int main ( void )
{
B test ( 59, 76 );
foo ( test );
return 0;
}

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

13.:

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
virtual void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A * val )
{
val -> print ( );
}

int main ( void )
{
B test ( 92, 90 );
foo ( & test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program nepůjde zkompilovat

(13.) Zobrazí:

14.:

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
friend ostream & operator << ( ostream & os, const A & x )
{ return os << x . m_X; }
private:
int m_X;
};

void foo ( A & val )
{
cout << val;
}

int main ( void )
{
B test ( 35, 57 );
foo ( test );
return 0;
}

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou pamět

(14.) Zobrazí?

15.:

class A
{
public:
A ( int x = 60 ) { m_X = new int (x); }
A ( const A & src ) { m_X = new int ( *src . m_X ); }
virtual ~A ( void ) { delete m_X; }
virtual void print ( void ) const { cout << *m_X; }
private:
int *m_X;
};

void foo ( const B val )
{
val . print ( );
}

int main ( void )
{
B test ( 44, 94 );
foo ( test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

(15.) Zobrazí?

16.:

class A
{
public:
A ( int x = 50 ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : A
{
public:
B ( int x, int y ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( B & val )
{
val . print ( );
}

int main ( void )
{
B test ( 44, 94 );
foo ( test );
return 0;
}

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

(16.) Zobrazí?

17.:

class A
{
public:
A ( int x = 54 ) { m_X = new int (x); }
A ( const A & src ) { m_X = new int ( *src . m_X ); }
virtual ~A ( void ) { delete m_X; }
virtual void print ( void ) const { cout << *m_X; }
private:
int *m_X;
};

void foo ( A * val )
{
val -> print ( );
delete val;
}

int main ( void )
{
foo ( new B ( 52, 84 ) );
return 0;
}

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje, ale neuvolní alokovanou paměť

Program nepůjde zkompilovat

(17.) Zobrazí?

18.:

class A
{
public:
A ( int x = 10 ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A val )
{
val . print ( );
}

int main ( void )
{
B test ( 11, 19 );
foo ( test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program nepůjde zkompilovat

(18.) Zobrazí?

19.:

class B : public A
{
public:
B ( int x ) : m_X ( x ) { cout << *this; }
virtual void print ( ostream & os ) const { os << "B:" << m_X; }
private:
int m_X;
};

int main ( void )
{
B test ( 57 );
return 0;
}

Program nepůjde zkompilovat

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program nespadne, ale výstup není definovaný

Program funguje, ale neuvolní alokovanou paměť

(19.) Zobrazí?

20.:

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( ostream & os ) const { A::print ( os ); os << m_Y;
}

friend ostream & operator << ( ostream & os, const B & x )
{ os << "B:"; x . print ( os ); return os; }
private:
int m_Y;
};

void foo ( A val )
{
cout << val;
}

int main ( void )
{
B test ( 35, 78 );
foo ( test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

Program nepůjde zkompilovat

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(20.) Zobrazí?

21.:

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
virtual void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A val )
{
val . print ( );
}

int main ( void )
{
B test ( 42, 41 );
foo ( test );
return 0;
}

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(21.) Zobrazí?

22.:

class B : public A
{
public:
B ( int x ) { m_X = x; }
virtual void print ( ostream & os ) const { os << "B:" << m_X; }
private:
int m_X;
};

int main ( void )
{
B test ( 53 );
return 0;
}

Program nespadne, ale výstup není definovaný

Program nepůjde zkompilovat

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

(22.) Zobrazí?

23.:

class A
{
public:
A ( int x ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A & val )
{
val . print ( );
}

int main ( void )
{
B test ( 59, 58 );
foo ( test );
return 0;
}

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(23.) Zobrazí?

24.:

class A
{
public:
A ( void ) { cout << *this; }
virtual ~A ( void ) {}
virtual void print ( ostream & os ) const = 0;
friend ostream & operator << ( ostream & os, const A & x )
{ x . print ( os ); return os; }
};

class B : public A
{
public:
B ( int x ) { m_X = x; }
virtual void print ( ostream & os ) const { os << "B:" << m_X; }
private:
int m_X;
};

int main ( void )
{
B test ( 95 );
return 0;
}

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

25.:

class B : public A
{
public:
B ( int x, int y ) : A ( x ) { m_Y = y; }
virtual void print ( ostream & os ) const { A::print ( os ); os << m_Y;
}

friend ostream & operator << ( ostream & os, const B & x )
{ os << "B:"; x . print ( os ); return os; }
private:
int m_Y;
};

void foo ( B & val )
{
cout << val;
}

int main ( void )
{
B test ( 66, 23 );
foo ( test );
return 0;
}

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

(25.) Zobrazí?

26.:

class A
{
public:
A ( void ) { cout <<"A:"; }
virtual ~A ( void ) {}
virtual void print ( ostream & os ) const = 0;
friend ostream & operator << ( ostream & os, const A & x )
{ x . print ( os ); return os; }
};

class B : public A
{
public:
B ( int x ) : m_X ( x ) { cout << *this; }
virtual void print ( ostream & os ) const { os << "B:" << m_X; }
private:
int m_X;
};

int main ( void )
{
B test ( 98 );
return 0;
}

Program nepůjde zkompilovat

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program nespadne, ale výstup není definovaný

Program funguje, ale neuvolní alokovanou paměť

Program funguje zcela správně, zobrazí:

(26.) Zobrazí?

27.:

class A
{
public:
A ( int x ) { m_X = x; }
virtual ~A ( void ) {}
friend ostream & operator << ( ostream & os, const A & x )
{ return os << x . m_X; }
private:
int m_X;
};

void foo ( A val )
{
cout << val;
}

int main ( void )
{
B test ( 65, 81 );
foo ( test );
return 0;
}

Program funguje zcela správně, zobrazí:

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje, ale neuvolní alokovanou pamět

Program nepůjde zkompilovat

(27.) Zobrazí?

28.:

void foo ( A & val )
{
cout << val;
}

int main ( void )
{
B test ( 78, 42 );
foo ( test );
return 0;
}

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(28.) Zobrazí?

29.:

class A
{
public:
A ( int x = 34 ) { m_X = new int (x); }
A ( const A & src ) { m_X = new int ( *src . m_X ); }
~A ( void ) { delete m_X; }
virtual void print ( void ) const { cout << *m_X; }
private:
int *m_X;
};

void foo ( A * val )
{
val -> print ( );
delete val;
}

int main ( void )
{
foo ( new B ( 74, 47 ) );
return 0;
}

Program nepůjde zkompilovat

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

30.:

class A
{
public:
A ( int x = 60 ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( A & val )
{
val . print ( );
}

int main ( void )
{
B test ( 84, 42 );
foo ( test );
return 0;
}

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

Program nepůjde zkompilovat

(30.) Zobrazí?

31.:

class A
{
public:
A ( int x = 86 ) { m_X = x; }
void print ( void ) const { cout << m_X; }
private:
int m_X;
};

class B : public A
{
public:
B ( int x, int y ) { m_Y = y; }
void print ( void ) const { A::print (); cout << m_Y; }
private:
int m_Y;
};

void foo ( B val )
{
val . print ( );
}

int main ( void )
{
B test ( 43, 30 );
foo ( test );
return 0;
}

Program nepůjde zkompilovat

Program funguje zcela správně, zobrazí:

Program funguje, ale neuvolní alokovanou paměť

Program půjde zkompilovat, ale po spuštění může spadnout/spadne

(31.) Zobrazí?

{"name":"PA2: demo skillcheck vol3", "url":"https://www.quiz-maker.com/QPREVIEW","txt":"Test your knowledge of C++ memory management concepts with this comprehensive quiz! Delve into the intricacies of class inheritance, constructors, destructors, and dynamic memory allocation. Perfect for both budding developers and seasoned programmers looking to sharpen their skills.Key Features:55 challenging questionsMultiple choice and text answersImmediate feedback on your selections","img":"https:/images/course3.png"}