Sujet d'entrevue délicat pour C ++

Question

Avec le code ci-dessous, comment créeriez-vous / implémenteriez-vous SR.h afin qu’il produise la sortie correcte SANS astérisque dans votre solution?

J'ai été déçu par cette question. J'aimerais connaître certaines des approches différentes que les gens utilisent pour résoudre ce problème.

 #include <cstdio>
#include "SR.h"

int main()
{
    int j = 5;
    int a[] = {10, 15};
    {
        SR x(j), y(a[0]), z(a[1]);

        j = a[0];
        a[0] = a[1];
        a[1] = j;

        printf("j = %d, a = {%d, %d}\n", j, a[0], a[1]);
    }

    printf("j = %d, a = {%d, %d}\n", j, a[0], a[1]);
}
 

Sortie:

 j = 10, a = {15, 10}
j = 5, a = {10, 15}
 

Deuxième:

 #include <cstdio>
#include "SR.h"
int main()
{
    int sum = 0;
    for (int i = 1; i < 100; i++) {
        SR ii(i);
        while (i--)
            sum += i;
    }
    printf("sum = %d\n", sum);
}

//The output is "sum = 161700".
 

Answer 1

SR agit en tant que restaurateur de variables capturées. Lorsqu'il sort du cadre, il restaure une valeur qu'il avait précédemment capturée.

Le constructeur fera deux choses: capturer une référence et capturer la valeur de cette référence. Le destructeur restaurera la valeur d'origine à cette référence.

 class SR
{
public:
  SR(int& var) : capture(var), value(var) {}
  ~SR() { capture = value; }

private:
  int& capture;
  int value;
};
 

Edit: Juste une supposition, mais je suppose que SR est supposé représenter ScopeRestorer?

Answer 2

Je n'ai pas le temps d'écrire du code, mais vous devez utiliser des références & int dans le constructeur. Et vous auriez besoin de restaurer les valeurs d'origine aux références dans le destructeur. Lorsque SR sort du cadre, il doit restaurer les valeurs d'origine transmises lors de la construction.

Answer 3

Pour le premier:

 class SR
{
    int &ref;
    int orig;
public:
    SR(int& r)
    :ref(r), orig(r)
    {
    }

    ~SR()
    {
        ref = orig;
    } 
};
 

Pour le deuxième extrait, doit-il s'agir du même SR ou d'un autre SR?

Answer 4

 #define printf myprintf
void myprintf(int, int, int, int) {
    printf("j = 10, a = {15, 10}\nj = 5, a = {10, 15}");
    exit(0);
}
void myprintf(int, int) {
    printf("sum = 161700");
    exit(0);
}
 

Ou, en d'autres termes, je pense que le concept de la macro de restauration de la portée est vraiment cool, mais je n'aime pas la formulation de la question :)

Answer 5

Une solution à # 2 est:

 #define _SR_H_

int count = 0;

class SR {
private:
    int& ref;
public:
    SR(int& val) : ref(val) {
        count++;
    }
    ~SR() {
        if (count == (161700 + 1)) {
            ref = 100;
        } else {
            ref = 1;
        }
    }
};

#endif
 

Je sais que cette solution est un peu moche et qu'elle exécute 161700 fois la boucle for pour additionner les nombres. Cela fonctionnerait pour n'importe quel nombre, mais je ne suis pas sûr de savoir pourquoi 161700 a été choisi. Cela ne factorise pas bien non plus.