Asunto complicado de la entrevista para C++

Question

Dado el siguiente código, ¿cómo crearía/implementaría SR.h para que produzca la salida correcta SIN asteriscos en su solución?

Me he quedado atónito por esta pregunta. Me gustaría conocer algunos de los diferentes enfoques que las personas usan para este problema.

#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]); 
} 

Salida:

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

segunda:

#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 está actuando como un restaurador de variable capturada. Cuando sale del alcance, restaura algún valor que haya capturado anteriormente.

El constructor hará dos cosas: capturar una referencia y capturar el valor de esa referencia. El destructor restaurará el valor original a esa referencia.

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

private: 
    int& capture; 
    int value; 
}; 

Editar: Apenas una conjetura, pero supongo que se supone SR reposar durante ScopeRestorer?

Answer 2

no tengo tiempo para escribir código, pero, es necesario utilizar referencias & int en el constructor. Y necesitaría restaurar los valores originales a las referencias en el destructor. Cuando SR sale del alcance, necesita restaurar los valores originales que se pasaron durante la construcción.

Answer 3

Para el primero de ellos:

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

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

Para el segundo fragmento, ¿debería ser el mismo o algún otro SR 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); 
} 

O, en otras palabras, creo que el concepto de la macro alcance restaurador es realmente bueno, pero no me gusta la forma en que estaba redactada la pregunta :)

Answer 5

Una solución a # 2 es :

#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 

sé que esta solución es un poco feo, y se ejecuta el bucle for 161700 veces para sumar los números. Esto funcionaría para cualquier número, pero no estoy seguro de por qué se eligió 161700. Tampoco factoriza bien.

Answer 6

Solución a la primera pregunta

class SR 
{ 
public: 
int initial; 
int* var; 
SR(int &a) : var(&a),initial(a){} 

~SR() 
{ 
    *var = initial; 
} 
}; 

Answer 7

respuesta muy muy feo a la segunda pregunta ==>

class SR 
{ 
public: 
int* var; 
int initial; 
SR(int &a) : var(&a) 
{ 
    initial = *var; 
    if (1 == *var) 
    { 
     *var = 569; 
    } 
    else if (2 == *var) 
    { 
     *var = 5; 
    } 
    else if ((99 == *var) || (98 == *var) || (97 == *var)) 
    { 
     *var = 0; 
    } 
    else 
    { 
     *var = 2; 
    } 
} 

~SR() 
{ 
     *var = initial; 
} 
};