Dato il seguente frammento di codice:

  class C1
    {
   public:
    C1(int counter = 0)
      { m_counter = counter; }
    void stampa(char ch,int counter = 0)
      {
      if(!counter) counter = m_counter;
      while (counter-- > 0) putchar(ch);
      }
   private:
    int m_counter;
    };
  C1 c1(4),c2;
  c1.stampa('x');
  c1.stampa('y',3);
  c1.stampa('z',2);
  c2.stampa('y');

Sia dato il seguente frammento di codice:

  template <typename T>
  inline void swap(T &a, T &b)
    { T t = a;  a = b;  b = t; }
  ...
  class Vettore
    {
   public:
    Vettore(int numElem)
      { m_numElem = numElem;
        m_v = new int [m_numElem]; }
    ~Vettore() { delete [] m_v; }
    void insert(int valore);
    ...
   private:
    int m_numElem;
    int *m_v;
    };

  Vettore x(10);
  ... // x viene inizializzato a { 1,2,3,4,5,6,7,8,9,10 }
  x.insert(55);
  // x contiene { 55,1,2,3,4,5,6,7,8,9 }

void Vettore::insert(int valore)
  {
  for(int j = 0; j < m_numElem; j++)
    swap(m_v[j],valore);
  }

void Vettore::insert(int valore)
  {
  for(int j = 1; j < m_numElem; j++)
    swap(m_v[j],valore);
  }

void Vettore::insert(int valore)
  {
  for(int j = m_numElem; j >= 0; j--)
    swap(m_v[j],valore);
  }

void Vettore::insert(int valore)
  {
  for(int j = m_numElem - 1; j >= 0; j--)
    swap(m_v[j],valore);
  }

void Vettore::insert(int valore)
  {
  for(int j = m_numElem; j > 0; j--)
    swap(m_v[j],valore);
  }

  int k,j;
  const int NR = ..., NC = ...;
  float mat[NR][NC],*p = &mat[0][0];

  template <typename T>
  inline void swap(T &a, T &b)
    { T t = a;  a = b;  b = t; }
  ...
  char s1[] = "ABCDE", s2[] = "12345";
  char *p1 = s1, *p2 = s2;
  swap(p1,p2);
  printf("%s,%s",p1,s2);

  class Figura
    {
    ...
    static float perimetroCerchio(const Figura &f)
      {
      return 2 * 3.14 * f.pr.raggio;
      }
    ...
    };

  class Studente : public Persona
    {
    ...
    void fun1(...)
      { ... }
    ...
    };

 

  int k;
  Lista<int> lista;
  Lista<int>::Iterator p;
  ...
  for(k = 0, p = lista.Begin(); k < 5 && p != lista.End(); k++, p++)
    printf("%d",*p);

  template <class T>
  class CMatrix
    {
  public:
    inline CMatrix(int rows,int columns)
      : m_rows(0), m_columns(0), m_pBase(NULL)
      { set(rows,columns); }
    inline ~CMatrix()
      { reset(); }
    ...
    eventuale definizione dell'operatore di assegnamento
    ...
  private:
    void set(int rows,int columns)
      {
      // ... controlli sugli argomenti passati
      reset();
      m_rows = rows;
      m_columns = columns;
      m_pBase = new T [m_rows * m_columns];
      }
    void reset()
      {
      m_rows = 0; m_columns = 0;
      delete [] m_pBase; m_pBase = NULL;
      }
    int m_rows;    // Numero di righe della matrice
    int m_columns; // Numero di colonne della matrice
    T *m_pBase;    // Indirizzo del primo elemento della matrice
    };

CMatrix &operator =(const CMatrix &from)
  {
  if(&from == this) return *this;

  set(from.m_rows,from.m_columns);
  for (int k = 0; k < m_rows * m_columns; k++)
    m_pBase[k] = from.m_pBase[k];
  return *this;
  }

CMatrix &operator =(const CMatrix &from)
  {
  if(&from == this) return *this;
  set(from.m_rows,from.m_columns);
  return *this;
  }

CMatrix &operator =(const CMatrix &from)
  {
  if(&from != this) reset();
  m_rows = from.m_rows;
  m_columns = from.m_columns;
  m_pBase = from.m_pBase;
  return *this;
  }

CMatrix &operator =(const CMatrix &from)
  {
  m_rows = from.m_rows;
  m_columns = from.m_columns;
  for (int k = 0; k < m_rows * m_columns; k++)
    m_pBase[k] = from.m_pBase[k];
  return *this;
  }

  const char s1[] = "\"abc\"\n";

Dato il frammento di codice:

   struct Punto
     {

     int m_x;
     int m_y;
     };
   ...

   {
   Punto *pPto = new Punto;
   ...
   }

nell'ipotesi che sizeof(int) == 4 e sizeof(int *) == 4, al momento dell'esecuzione vengono allocati:

  int bx[] = { 6,5,4,3,2,1 },*b = &bx[3];

  b[-3] / static_cast<double>(b[-1])

  class C1
    { ...
   public:


    virtual int fun1(double x,double y = 0.0);
    ... };
  ...
  C1 *pC = new C1(...);

  class A
    {
  public:
    virtual void Fun1() { ... }
    virtual void Fun2() { ... }
    void Fun3() { ... }
    ...
    };

  class B : public A
    {
  public:
    virtual void Fun1() { ... }
    static void Fun4() { ... }
    };
  ...
  {
  A a,*pA;
  B b,*pB;
  ...
  invocazione
  }

  class A
    {
  public:
    virtual ~A()
      {
      puts("Distruttore di A");
      Fun();
      }
    virtual void Fun()
      { puts("Fun di A"); }
    };

  class B : public A
    {
  public:
    virtual ~B()
      {
      puts("Distruttore di B");
      Fun();
      }
    virtual void Fun()
      { puts("Fun di B"); }
    };
  ...
  {
  B b1;
  ...
  }

Distruttore di B
Fun di B
Distruttore di A
Fun di A

Fun di B
Distruttore di B
Fun di B
Distruttore di A

Distruttore di B
Fun di B
Distruttore di A
Fun di B

Distruttore di A
Fun di A
Distruttore di B
Fun di B

  class A
    {
  public:
    A()
      { puts("Costruttore di A"); }
    virtual ~A()
      { puts("Distruttore di A"); }
    virtual void Fun()
      { puts("Fun di A"); }
    };

  class B : public A
    {
  public:
    B()
      { puts("Costruttore di B"); }
    virtual ~B()
      { puts("Distruttore di B"); }
    virtual void Fun()
      { puts("Fun di B"); }
    };
  ...
  {
  B b;
  b.Fun();
  }

Costruttore di A
Costruttore di B
Fun di B
Distruttore di B
Distruttore di A

Costruttore di B
Fun di B
Distruttore di B

Costruttore di B
Costruttore di A
Fun di B
Distruttore di A
Distruttore di B

Costruttore di A
Costruttore di B
Fun di B
Distruttore di A
Distruttore di B

Costruttore di A
Fun di B
Distruttore di A

 

  int k;
  Lista<int> lista;
  lista.AddHead(10);
  lista.AddHead(20);
  lista.AddHead(30);
  lista.AddHead(40);
  Lista<int>::Iterator p;
  for(k = 3, p = lista.Begin(); k > 0 && p != lista.End(); k--, p++)
    printf("%d ",*p);

Nella seguente dichiarazione della classe generica Stack:

  template <class T,MaxElem = 200>
  class Stack
    {
  public: 
    Stack()
      { nelem = 0; }
    void push(const T &newElem) 
      { if(isFull()) throw "Stack pieno";
        elem[nelem++] = newElem; }
    T pop()
      { if(isEmpty()) throw "Stack vuoto";
        return elem[--nelem]; }
    bool isEmpty() const
      { return nelem == 0; }
    bool isFull() const
      { return nelem > MaxElem; }
  private:
    int nelem;
    T elem[MaxElem];
    };

  enum Colore { rosso, blu, giallo };

  static const char * const nome[] = {"",
   "Gennaio","Febbraio","Marzo",
   "Aprile","Maggio","Giugno",
   "Luglio","Agosto","Settembre",
   "Ottobre","Novembre","Dicembre"};

Date le definizioni:

  int a[] = { 1, 2, 3, 4, 5 }; 
  int *p1 = new int [10];
  const int *p2;

quale delle seguenti istruzioni genera un errore in fase di compilazione?

Date le definizioni:

  inline int fun1(int &a)
    { return a + 2; }
  inline int fun1(int *a)
    { return *a + 1; }

quale dei seguenti frammenti di codice NON assegna a x il valore 5?

int x = 1,&y = x,*z = &y;
x = fun1(&x) + fun1(z);

int x = 0,&y = x,*z = &y;
x = 1 + fun1(x) + fun1(y);

int x = 1,&y = x,*z = &x;
x += fun1(&x) + fun1(z);

int x = 1,&y = x,*z = &y;
x = fun1(x) + fun1(&y);

int x = 1,&y = x,*z = &x;
x = fun1(&x) + fun1(y);

  int bx[] = { 7,6,5,4,3,2,1 },*b = &bx[3];

L'espressione:

   a || b

è esattamente equivalente all'espressione:

   char x[] = "123456",y[] = "12345678";

   bool test(const char *p1,const char *p2)
     {
     while (*p2)
       if(*p1++ != *p2++) return false;
     return true;
     }

Date le definizioni:

  char a[] = { '1', '2', '3', '4', '5' }; 
  char *s1 = new char [10];
  const char *s2;

quale delle seguenti istruzioni genera un errore in fase di compilazione?

Date le definizioni:

  char a[] = { '1', '2', '3', '4', '5' }; 
  char *s1 = new char [10];
  const char *s2 = a;

quale dei seguenti frammenti di codice genera un errore in fase di esecuzione?