C++ - Heap corruption detected

Nemam cas to cele kontrolovat ale za prve kazde vyvojove prostredie umoznuje debugovat krok za krokom a v pripade takeho problemu by to malo zastat na tom probleme a vies si pozret premenne. Nauc sa pouzivat debugger, inac budes pri komplikovanejsich veciach uplne strateny.

Za druhe proste niekde zapisujes do pola na vyssi index jak je velkost pola. Ked sa take nieco stava tak to znamena ze mas uplne nahovno vymysleny cely koncept resp. mas v nom sam chaos (ze co je v ktorej premennej a preco, napr. mas viac premennych ktore urcuju defakto to iste a je medzi nimi nekonzistencia apod). Skus si premyslet cely koncept ze ako to urobit tak aby sa ti nestavalo ze niekam zapisujes nezmysly.

Jakej koncept? Chudaka jsi ho zkritizoval, pritom "do pole vyssi index jak je velikost pole" neznamena vsechno na prd, naopak typicky to znamena spatnou/neinicializovanou proměnnou či překlep.

S tymto ale nesuhlasim. Prepisanie mimo pola je uplne najhrubsia hrubka to sa proste dobremu koderovi IMHO nesmie stat ani keby neviemco bolo. A aj keby len neinicializoval premennu tak to je potom tiez chaos v koncepte premennych

tym netvrdim ze mne sa to nikdy nestalo (uz sa nepamatam :D) ale ak, tak to bol pre mna alarm signal ze "trubka zamysli sa mas v tom uz chaos" :)

Zkusil jsem napsat kompletně nový kód, problém mi dělá načítání hodnoty do cislo2 (64. řádek) - hodnoty se načtou, ale jakmile program opustí cyklus, ihned se cislo2[0] a cislo2[1] přepíšou na -8...(strašně moc čísel :D) - čím to může být? Za chvíli mi z toho asi uletí hlava :D

#include<iostream>
#include<string>

using namespace std;

int main(){
	string vstup;

	cout << "Zadejte dve binarni cisla:" << endl;
	getline(cin, vstup);
	int delka_vstup = vstup.length(); 

	int mezera = 0;
	int delka1 = 0;
	int delka2 = 0;
	
	//urcim pocet mezer, osetrim vstup jinych znaku
	int i; //adresa mezery
	int adresa_posledniho_prvku = delka_vstup-1;

	for(int j = 0; j <= adresa_posledniho_prvku; ++j){
		if(vstup[j] != ' ' && vstup[j] != '1' && vstup[j] != '0'){
			cout << "Nespravny vstup." << endl;
			return 0;
		}
		if(vstup[j] == ' '){
			i = j;
			++mezera;
		}
	}

	//osetrim pocet mezer
	if(mezera != 1){
		cout << "Nespravny vstup." << endl;
		return 0;
	}

	//urcim delky poli
	int a; //index konce cislo1
	for(a = 0; a < i; ++a){
		++delka1;
	}
	--a;
	int b; //index konce cislo2
	for(b = i+1; b < delka_vstup; ++b){
		++delka2;
	}
	--b;

	int max_delka; //delka vetsi ze vstupnich hodnot - pouziju pro alokaci obou poli
	if(delka1 > delka2){
		max_delka = delka1;
	}else{
		max_delka = delka2;
	}

	int *cislo1 = new int [max_delka];
	int *cislo2 = new int [max_delka];

	//zapisu hodnoty do poli
	for(int j = 0; j <= a; ++j){
		cislo1[j] = vstup[j]-48;
	}

for(int j = i+1; j <= b; ++j)
cislo2[j - i+1] = vstup[j]-48;
}
cout << cislo2[0] << cislo2[1] << cislo2[2] << endl;

	//zbytek poli vyplnim nulami
	for(int j = a+1; j < max_delka; ++j){
		cislo1[j] = 0;
	}
	for(int j = b+1; j < max_delka; ++j){
		cislo2[j] = 0;
	}

	cout << cislo1[0] << cislo1[1] << cislo1[2] << endl;
	cout << cislo2[0] << cislo2[1] << cislo2[2] << endl;

	int *soucet = new int [max_delka+1];

	int bon = 0; //"bonus" pri scitani, prechazejici na dalsi pozici
	int c = 0;
	for(int j = 0; j < max_delka; ++j){
		if(cislo1[j] + cislo2[j] + bon == 0){
			soucet[c] = 0;
			bon = 0;
		}else if(cislo1[j] + cislo2[j] + bon == 1){
			soucet[c] = 1;
			bon = 0;
		}else if(cislo1[j] + cislo2[j] + bon == 2){
			soucet[c] = 0;
			bon = 1;
		}else if(cislo1[j] + cislo2[j] + bon == 3){
			soucet[c] = 1;
			bon = 1;
		}
		++c;
	}

	int zkouska = 0;
	cout << "Soucet: ";
	for(int j = 0; j <= max_delka; --j){
		if(soucet[i] == 1){ //kontrola 1 mezery
		zkouska = 1;
		}
		if(zkouska == 1){
			cout << soucet[j];
		}
		if(i == 0 && zkouska == 0){
			cout << 0;
		}
	}
	cout << endl;

	delete[] cislo1;
	delete[] cislo2;
	delete[] soucet;

	return 0;
}

Tvoj problem podla mna je
j - i+1
prekladac neni jasnovidec bud j - (i+1) alebo j - i - 1.

Inac robis moc zlozito vsetko. ja by som dynamicky vytvoril len pole pre vysledok a ratal by som to rovno zo vstupu. Tie polia cislo1 a cislo2 vytvaras uplne zbytocne.
Inac len tak mimochodom:

	int adresa_posledniho_prvku = delka_vstup-1;

	for(int j = 0; j <= adresa_posledniho_prvku; ++j){

staci takto:

	for(int j = 0; j < delka_vstup; ++j){

alebo

	//urcim delky poli
	int a; //index konce cislo1
	for(a = 0; a < i; ++a){
		++delka1;
	}
	--a;
	int b; //index konce cislo2
	for(b = i+1; b < delka_vstup; ++b){
		++delka2;
	}
	--b;

je presa to iste co

	int a=i-1; //zasa dalsia zbytocna premenna
	delka1=i;
	int b= delka_vstup-i-1; //zbytocna premenna
	delka2=delka_vstup-i-1;

Já jsem taky vůl :D Díky

jinak, i v tomhle vidím chybu, doplňuju nuly, ale až za zadané číslo, tj. ve výsledku pak počítám třeba s 00100 :D

Takže to zkusím ještě jednou, jen mě zajímá - když mám třeba 001 00001, jak s tím mám počítat, když nejsou čísla stejně dlouhá (proto jsem vytvářel ta další pole)?

Napr. ze na zaciatku si nastavis 2 premenne "pozicia_cislo1" a "pozicia_cislo2" na index poslednej cifry cisel vo vstupnom poli, a premenne zaciatok_cislo1 a zaciatok_cislo2 na poziciu prvej cifry vo vstupnom poli.
Potom len vytvoris vystupne pole, a mozes hned ratat, nieco ako

int cifra1,cifra2,prenos;
prenos=0;
for(i=0;i<velkost_vystupneho_pola;i++) // pre kazdu cifru vystupneho pola
{
 if(pozicia_cislo1<zaciatok_cislo1) // som uz mimo cisla1?
  cifra1=0;                         // tak potom nula
 else
  cifra1=vstup[pozicia_cislo1--] - '0';

 if(pozicia_cislo2<zaciatok_cislo2) // som uz mimo cisla2?
  cifra2=0;                         // tak potom nula
 else
  cifra2=vstup[pozicia_cislo2--] - '0';

 //a teraz si vyratas sucet cifra1+cifra2+prenos a nastavis podla toho vystup[i] a prenos
 vystup[i]=(cifra1+cifra2+prenos)%2;
 prenos=(cifra1+cifra2+prenos)/2;
} // konec cyklu a aj celeho programu :D

P.S. zaklad optimalneho programovania je okrem inych veci aj zakazdym ked chces urobit novu premennu alebo pole sa najprv zamyslet co uz mam v stavajucich premennych a poliach, a nevytvarat zbytocne nove premenne a polia so stejnymi datami ak uz tie data niekde mam v stavajucej premennej. Akurat ked chcem nejaku premennu menit a zartoven si ale aj zachovat povodnu hodnotu tak novu premennu samozrejme potrebujem. V mojom pripade to su tie pozicia_cisla1 a 2, tie chcem v cykle menit tak preto som ju vytvoril extra, aj ked poziciu poslednej cifry by som si vedel zakazdym vyratat z premennych ktore som uz mal.
Ale nerob si stres, optimalne dnes neprogramuje uz asi skoro nikto ani v profesionalnom celosvetovom meritku, mozog je totiz celosvetovo nedostatkovy tovar :D Dnes ide len o to zaskrtnut v nejakom dementnom managerskom SW ze je naplanovany bod implemented a accepted, a ziaden flag ze "je to uplna sracka" manager v programe nema takze to nikoho nezaujima :D

Vies co zober ten povodny program a toto

	int *cislo1 = new int[delka3];
	int *cislo2 = new int[delka3];

zmen na

	int *cislo1 = new int[delka3+1];
	int *cislo2 = new int[delka3+1];

pretoze ked pises ze ti po tom zmeneni <=delka3 na <delka3 blbne najvyssia cifra tak evidentne pouzivas z tych poli asi aj ten dalsi znak ktory si tam nemal. Funguje to potom?

Super, tebe musím někdy pozvat na pivo :D Moc díky

A vyskytl se ještě jeden (a snad už poslední) problém - školní systém mi to nebere, protože prý mám 2 neuvolněné paměťové bloky - jak je to možné, když na konci používám ke všem 3 polím delete?

neviem co myslis tym skolni system, ale skusal si to uz aj opravene? Pretoze ten povodny program ak prepisal nieco mimo pola tak mohol prepisat udaje o tom poli a potom program nevie co ma vlastne uvolnit. prepisovanie mimo pola je ten najvacsi bubak ktory by ta mal strasit pri kazdom riadku :D preto na to treba mysliet a cykly robit tak aby indexy uplne nabeton nemohli prekrocit velkost pola do ktoreho zapisujem :) Alebo si urobit triedu "dyn_pole" a pristupy umoznit len cez metodu a v nej kontrolovat index.
Ak to pinda aj u opraveneho programu tak daj vediet co presne to hlasi.

Nakonec jsem si všiml, že u ošetření nesprávných vstupů jsem zapomněl mazat alokovanou paměť + jsem udělal významný objev - ty "samoopravovací" systémy neberou knihovny jako třeba vld.h (od Visual Leek Detector). Takže ještě jednou moc díky za rady, už to funguje...