Maker LogoMake your own Copy & Edit
Make your own Manage my SurveysPlans / FeaturesGuides and HelpContactPrivacy & 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 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 ( 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;
};

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 ( 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;
};

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 ( 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;
};

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 ( 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 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 ) : 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 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 ( 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 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 ) { 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 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 ( 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;
};

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 ( 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.:
 
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 ( 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;
};

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 ( 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"}

More Surveys

Design Patterns Quiz
10525
Behavioral & Structural Design Pattern Quiz Quiz
10516
Chapter 2 Meaningful Names & Chapter 3 Functions
10511
Linting rules
10510
ISTQB Test
11616
The Scrum Framework
1477
Test automation training - entry knowledge check
10525
Agile Maturity Test
1050
Payment Terminal & E-Financing Market Survey
15829
VIDEO BORA KWA MWAKA 2022/2023 [@director_chasama]
100
What people did to distract themselves during quarantine?
15830
What do YOU want from a newsletter?
630
Quiz Maker Logo Make your own Quiz
Powered by: Quiz Maker