Mensajes

Sois tan brillantes como un agujero negro y el doble de denso

No se hacen tareas, a mendigar a otra parte.

Y luego las operaciones de adición y division como se sacan

ADD y DIV AB.

Leete todo esto.

https://en.wikipedia.org/wiki/Intel_8051
https://en.wikipedia.org/wiki/Intel_8051#Instruction_set
https://www.tutorialspoint.com/8051-program-to-add-two-8-bit-numbers
https://www.tutorialspoint.com/8051-program-to-divide-two-8-bit-numbers

O lo va guardando en memoria o en un registro que no se vea afectado por el resto de oepraciones que quiere hacer.

De nadas  Y eso es con el codigo optimizado por el compilador, podria ser asi en debug:

ctor n 0000023ACEFD8FE0 object 000000C8C87FFE78
ctor n 0000023ACF023FE0 object 000000C8C87FFE68
1       7       4       0       9
4       8       8       2       4
ctor n 0000023ACF029FE0 object 000000C8C87FFE98
ctor n 0000023ACF02FFE0 object 000000C8C87FFE18
ctor n 0000023ACF035FE0 object 000000C8C87FFEA8
copy n 0000023ACF035FE0 object 000000C8C87FFEA8
dtor n 0000023ACF02FFE0 object 000000C8C87FFE18
ope= n 0000023ACF029FE0 object 000000C8C87FFE98
dtor n 0000023ACF035FE0 object 000000C8C87FFEA8
5       15      12      2       13
ctor n 0000023ACF04DFE0 object 000000C8C87FFE18
ctor n 0000023ACF053FE0 object 000000C8C87FFE88
copy n 0000023ACF053FE0 object 000000C8C87FFE88
dtor n 0000023ACF04DFE0 object 000000C8C87FFE18
5       15      12      2       13
dtor n 0000023ACF053FE0 object 000000C8C87FFE88
dtor n 0000023ACF047FE0 object 000000C8C87FFE98
dtor n 0000023ACF023FE0 object 000000C8C87FFE68
dtor n 0000023ACEFD8FE0 object 000000C8C87FFE78

Basicamente estas accediendo a memoria ya liberada.

https://en.cppreference.com/w/cpp/language/rule_of_three

Supongamos que:

Código (c++) [Seleccionar] Expandir

vector::vector(int t):tamano(t) {
    n = new int[tamano];
    std::cout << "ctor n " << n << " object " << this << std::endl;
    llenar();
}
     
vector::~vector() {
    std::cout << "dtor n " << n << " object " << this << std::endl;
    delete[] n;
}

Código (c++) [Seleccionar] Expandir

int main() {
    vector a, b;
    a.visualizar();
    b.visualizar();
    vector z = a;

ctor n 0000020069C0A6E0 object 000000C9E96FF838 //constructor de a
ctor n 0000020069C0A720 object 000000C9E96FF848 //constructor de b
1       7       4       0       9
4       8       8       2       4
dtor n 0000020069C0A6E0 object 000000C9E96FF878 //destructor de z!
dtor n 0000020069C0A720 object 000000C9E96FF848 //destructor de b
dtor n 0000020069C0A6E0 object 000000C9E96FF838 //destructor de a

"Because C++ copies and copy-assigns objects of user-defined types in various situations (passing/returning by value, manipulating a container, etc), these special member functions will be called, if accessible, and if they are not user-defined, they are implicitly-defined by the compiler."

¿Que definio el compilador para el constructor de copia? Una copia byte por byte:

Código (asm) [Seleccionar] Expandir

  0003c 48 8d 44 24 68 lea rax, QWORD PTR z$[rsp]
  00041 48 8d 4c 24 28 lea rcx, QWORD PTR a$[rsp]
  00046 48 8b f8 mov rdi, rax
  00049 48 8b f1 mov rsi, rcx
  0004c b9 10 00 00 00 mov ecx, 16
  00051 f3 a4 rep movsb

Por eso z.n es igual a a.n y eso no es bueno ya que se terminara liberando dos veces.

Si lo definimos nosotros:

Código (c++) [Seleccionar] Expandir

vector(const vector &r) : vector(r.tamano)
{
    memcpy(n, r.n, tamano * sizeof(int));
}

ctor n 0000025A0CD6A820 object 000000935CFCFB88 //a
ctor n 0000025A0CD6A740 object 000000935CFCFB98 //b
1       7       4       0       9
4       8       8       2       4
ctor n 0000025A0CD6A760 object 000000935CFCFBC8 //z
dtor n 0000025A0CD6A760 object 000000935CFCFBC8 //~z
dtor n 0000025A0CD6A740 object 000000935CFCFB98 //~b
dtor n 0000025A0CD6A820 object 000000935CFCFB88 //~a

Ahora pasamos a probar:

Código (c++) [Seleccionar] Expandir

vector c;
c = a + b;
c.visualizar();


Y comento el delete[] del destructor para que no explote el programa.

ctor n 0x8d13f0 object 0x79fdf0 //a
ctor n 0x8d1410 object 0x79fde0 //b
1       7       4       0       9
4       8       8       2       4
ctor n 0x8d1870 object 0x79fdd0 //c
ctor n 0x8d1890 object 0x79fe00 //resultado
dtor n 0x8d1890 object 0x79fe00 //~resultado
9263792 0       9240912 0       13
dtor n 0x8d1890 object 0x79fdd0 //~c

¿Cual es el problema? El operador de asignacion definido por el compilador hace que c.n sea igual a resultado.n (un n que inmediatamente es liberado al ejecutarse el destructor del objeto resultado).

Fijate si podes implementarlo siguiendo la logica demostrada en el enlace del principio de mi mensaje.

Tendrias que llegar a algo asi con el main original:

ctor n 0xae13f0 object 0x79fdf0 //a
ctor n 0xae1410 object 0x79fde0 //b
1       7       4       0       9
4       8       8       2       4
ctor n 0xae1870 object 0x79fdd0 //c
ctor n 0xae1890 object 0x79fe00 //resultado
ope= n 0xae1870 object 0x79fdd0 //c = resultado
dtor n 0xae1890 object 0x79fe00 //~resultado
5       15      12      2       13
ctor n 0xae1890 object 0x79fdc0 //d y resultado son lo mismo en este caso, esta optimizada la asignacion y por eso funciona 
5       15      12      2       13
dtor n 0xae1890 object 0x79fdc0 ;~d
dtor n 0xae1870 object 0x79fdd0 ;~c
dtor n 0xae1410 object 0x79fde0 ;~b
dtor n 0xae13f0 object 0x79fdf0 ;~a

[no es C++ standard]

A mí esa línea de código no me arroja error .... quizás te referís a declaración de errores inexactas de algún IDE; Qué IDE usas ? En Codeblocks 20.03 no tuve problemas .... y mirá que es bastante " sensible "

Como ya te explicaron no es C++ standard, igual que conio.h, tenes suerte de que no te de error al compilar.

Claro que funciona si inicializas a 0 manualmente una variable local, no hay ninguna razon para esperar un comportamiento diferente.

Necesitas leer algun libro de C++ urgentemente, entender la diferencia entre variables locales y globales es algo muy elemental.

[variable global]

No hay ninguna operador sobrecargado, es una elemental suma de enteros entre una variable global y un elemento de un array cuyo resultado se asigna a la variable global.

Es exactamente igual a esto:

Código (c++) [Seleccionar] Expandir

resultado += arreglo[a];

1) mayor es una variable global y su valor inicial es 0 por defecto. ¿Que crees que deberia ser? Es eso o un valor indefinido ya que no inicializaste la variable ... por suerte no hace falta al ser una variable global.

Me cito, cambia mayor por resultado.

De nada; las lineas que te señalo K-YreX  tambien esta mal, estas usando sizeof de num_nodos que siempre sera lo mismo ...

El problema no tiene nada que ver con scanf. Con el Application Verifier puede reproducirlo con cualquier cifra. Ejemplo:

numero es 5
ORDEN_MATR es 25
En la linea 35 eventualmente j sera mayor a 4.

Código (c++) [Seleccionar] Expandir

for (i = 0; i < ORDEN_MATR; i++)
for (j = 0; j < ORDEN_MATR; j++)
matr_adher [i][j] = 0;

Pero en la linea 27 reservaste memoria para 5 enteros, no 25. Tres cuartos de lo mismo te pasara con la linea 37.