Errore con la memora Heap

MagoMiratempo

il 14 mar 2023, 19:03

11 risposte

MagoMiratempo

Pochi posts

Iscritto da: feb, 2023

Messaggi:: 30

Errore con la memora Heap

14 mar 2023, 19:36

Salve Qualcuno sa da cosa potrebbe essere causato questo errore

11 Risposte

O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21265
Re: Errore con la memora Heap
14 mar 2023, 20:30
A occhio sembra che sia corrotto l'heap molto probabilmente a causa di una scrittura in memoria tramite un puntatore non valido o in un'area non allocata

MagoMiratempo

Pochi posts

Iscritto da: feb, 2023

Messaggi:: 30

Re: Errore con la memora Heap

15 mar 2023, 12:35

Durante l'esecuzione del codice mi da anche un altro errore:

Eccezione non gestita in 0x00007FFD4230F6A9 (ntdll.dll) in Main_Traiding_C++.exe: 0xC0000374: Heap danneggiato (parametri: 0x00007FFD423797F0).

in riga:

std::cout << static_cast<int>(percent) << "%"; // Aggiungi flush per svuotare il buffer di output

il codice completo è:

bool Grafica::PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU, WORD colorP, WORD colorN)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }

    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << "] ";

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorN);
    std::cout << static_cast<int>(percent) << "%"; // Aggiungi flush per svuotare il buffer di output
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);

    if (DaA) {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorPRO);
        std::cout << " " << static_cast<int>(progress) << "\\" << static_cast<int>(total) << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }
    else {
        std::cout << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21265
Re: Errore con la memora Heap
15 mar 2023, 14:09
Stessa storia di prima, heap danneggiato e i motivi possono essere mille. Poco importa che venga rilevato in quella linea, le cause sono precedenti e magari chissà dove nel codice (non sono in questa funzione).
Intanto puoi controllare se completeChars e incompleteChars per qualche motivo non diventino minori di 0.
Poi potresti procedere eliminando parti di codice fino a quando il problema non si manifesta più.
Oppure fare debugging “spinto” linea per linea (ma è complesso)
M
MagoMiratempo
Pochi posts
Iscritto da
feb, 2023
Messaggi:
30
Re: Errore con la memora Heap
15 mar 2023, 19:44
Sono disperato non so piu' dove mettere le mani, mi potresti aiutare a trovare l'errore o gli errori, grazie mille in anticipo.
M
MagoMiratempo
Pochi posts
Iscritto da
feb, 2023
Messaggi:
30
Re: Errore con la memora Heap
15 mar 2023, 19:46
#include <Lib.h>
#include <Lib/Grafica.h>
using namespace Grafica;
using namespace std;
#define TRAIDING 1
#define RETURN_COYN 2
#define DATA_COYN 3
#define COYN 4
typedef const char* CDATA;
//string sha256(string msg);
//string toHex(unsigned int num);
// Costanti per la funzione hash SHA-256
const unsigned int K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
string sha256(string msg) {
// Inizializzazione dei valori intermedi di hash
unsigned int H[8] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
};
// Preparazione del messaggio
unsigned int len = msg.length();
unsigned int padLen = 64 - ((len + 9) % 64);
if (padLen < 1) {
padLen += 64;
}
unsigned char* paddedMsg = new unsigned char[len + padLen + 8];
for (unsigned int i = 0; i < len; i++) {
paddedMsg[i] = msg[i];
}
paddedMsg[len] = 0x80;
for (unsigned int i = len + 1; i < len + padLen; i++) {
paddedMsg[i] = 0x00;
}
unsigned long long bitLen = len * 8;
for (int i = 0; i < 8; i++) {
paddedMsg[len + padLen + i] = (unsigned char)(bitLen >> (56 - (i * 8)));
}
// Elaborazione del messaggio per blocchi di 512 bit
for (unsigned int i = 0; i < len + padLen + 8; i += 64) {
unsigned int W[64];
for (int j = 0; j < 16; j++) {
W[j] = ((unsigned int)paddedMsg[i + (j * 4)] << 24)
| ((unsigned int)paddedMsg[i + (j * 4) + 1] << 16)
| ((unsigned int)paddedMsg[i + (j * 4) + 2] << 8)
| ((unsigned int)paddedMsg[i + (j * 4) + 3]);
}
for (int j = 16; j < 64; j++) {
unsigned int s0 = ((W[j - 15] >> 7) | (W[j - 15] << 25))
^ ((W[j - 15] >> 18) | (W[j - 15] << 14))
^ (W[j - 15] >> 3);
unsigned int s1 = ((W[j - 2] >> 17) | (W[j - 2] << 15))
^ ((W[j - 2] >> 19) | (W[j - 2] << 13))
^ (W[j - 2] >> 10);
W[j] = W[j - 16] + s0 + W[j - 7] + s1;
}
unsigned int a = H[0];
unsigned int b = H[1];
unsigned int c = H[2];
unsigned int d = H[3];
unsigned int e = H[4];
unsigned int f = H[5];
unsigned int g = H[6];
unsigned int h = H[7];
for (int j = 0; j < 64; j++) {
unsigned int S1 = ((e >> 6) | (e << 26))
^ ((e >> 11) | (e << 21))
^ ((e >> 25) | (e << 7));
unsigned int ch = (e & f) ^ ((~e) & g);
unsigned int temp1 = h + S1 + ch + K[j] + W[j];
unsigned int S0 = ((a >> 2) | (a << 30))
^ ((a >> 13) | (a << 19))
^ ((a >> 22) | (a << 10));
unsigned int maj = (a & b) ^ (a & c) ^ (b & c);
unsigned int temp2 = S0 + maj;
h = g;
g = f;
f = e;
e = d + temp1;
d = c;
c = b;
b = a;
a = temp1 + temp2;
}
H[0] += a;
H[1] += b;
H[2] += c;
H[3] += d;
H[4] += e;
H[5] += f;
H[6] += g;
H[7] += h;
}
// Costruzione dell'hash finale
std::ostringstream result;
for (int i = 0; i < 8; i++) {
result << std::hex << std::setfill('0') << std::setw(8) << H[i];
}
delete[] paddedMsg;
return result.str();
}
struct Process
{
HANDLE* Traiding;
DWORD* TraidingError = NULL;
BOOL TraidingErrorNum = NULL;
PCHAR TraidingCom = nullptr;
DWORD TraidingNum = NULL;
LPCWCH TraidingPer;
HANDLE* ReturnCoyn;
DWORD* ReturnCoynError = NULL;
BOOL ReturnCoynErrorNum = NULL;
PCHAR ReturnCoyngCom = nullptr;
DWORD ReturnCoynNum = NULL;
LPCWCH ReturnCoynPer;
HANDLE* DataCoyn;
DWORD* DataCoynError = NULL;
BOOL DataCoynErrorNum = NULL;
PCHAR DataCoynCom = nullptr;
DWORD DataCoynNum = NULL;
LPCWCH DataCoynPer;
HANDLE* Coyn;
DWORD* CoynError = NULL;
BOOL CoynErrorNum = NULL;
PCHAR CoynCom = nullptr;
DWORD CoynNum = NULL;
LPCWCH CoynPer;
void Process_Free() {
delete Traiding;
delete[] TraidingError;
delete[] TraidingCom;
delete ReturnCoyn;
delete[] ReturnCoynError;
delete[] ReturnCoyngCom;
delete DataCoyn;
delete[] DataCoynError;
delete[] DataCoynCom;
delete Coyn;
delete[] CoynError;
delete[] CoynCom;
}
};
void Process_Per(Process& Process) {
Process.TraidingPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\x64\\Debug\\Traiding_C++.exe");
Process.ReturnCoynPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Return_Coyn\\x64\\Debug\\Return_Coyn.exe");
Process.DataCoynPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Data_Coyn\\x64\\Debug\\Data_Coyn.exe");
Process.CoynPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Coyn\\x64\\Debug\\Coyn.exe");
Process.TraidingCom = new char[strlen("_Traiding") + 1];
strcpy(Process.TraidingCom, "_Traiding");
Process.ReturnCoyngCom = new char[strlen("_ReturnCoyn") + 1];
strcpy(Process.ReturnCoyngCom, "_ReturnCoyn");
Process.DataCoynCom = new char[strlen("_DataCoyn") + 1];
strcpy(Process.DataCoynCom, "_DataCoyn");
Process.CoynCom = new char[strlen("_Coyn") + 1];
strcpy(Process.CoynCom, "_Coyn");
}
/*
void DirectoryCleaning(const char* path) {
std::string pathWithWildcard = std::string(path) + "\\*";
WIN32_FIND_DATAA fileData;
HANDLE hFind = FindFirstFileA(pathWithWildcard.c_str(), &fileData);
if (hFind == INVALID_HANDLE_VALUE) { std::cout << "Errore nella ricerca dei file nella directory" << endl; }
do
{
if (strcmp(fileData.cFileName, ".") != 0 && strcmp(fileData.cFileName, "..") != 0)
{
std::string fullPath = std::string(path) + "\\" + fileData.cFileName;
if (DeleteFileA(fullPath.c_str()) == FALSE)
{
std::cout << "Errore nella cancellazione del file " << fullPath << endl;
}
}
} while (FindNextFileA(hFind, &fileData) != FALSE);
FindClose(hFind);
}*/
bool IsFile(const char* path)
{
DWORD attributes = GetFileAttributesA(path);
if (attributes == INVALID_FILE_ATTRIBUTES)
{
// Il percorso non esiste
return false;
}
return (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
}
void DirectoryCleaning(const char* path) {
std::string pathWithWildcard = std::string(path) + "\\*";
WIN32_FIND_DATAA fileData;
if (GetFileAttributesA(path) != INVALID_FILE_ATTRIBUTES && (GetFileAttributesA(path) & FILE_ATTRIBUTE_DIRECTORY)) {
HANDLE hFind = FindFirstFileA(pathWithWildcard.c_str(), &fileData);
if (hFind == INVALID_HANDLE_VALUE) { std::cout << "Errore nella ricerca dei file nella directory" << endl; }
while (FindNextFileA(hFind, &fileData))
{
if (strcmp(fileData.cFileName, ".") != 0 && strcmp(fileData.cFileName, "..") != 0)
{
std::string fullPath = std::string(path) + "\\" + fileData.cFileName;
if (IsFile(fullPath.c_str())) {
if (DeleteFileA(fullPath.c_str()) == FALSE)
{
std::cout << "Errore nella cancellazione del file " << fullPath << endl;
}
}
}
}
FindClose(hFind);
}
else {
cout << "Cartella -> " << path << " <- non esiste" << endl;
}
}
struct Comunicazione
{
PCHAR Data = nullptr;

PCHAR New = nullptr;
PCHAR Close = nullptr;
PCHAR DataD = nullptr;
PCHAR Input = nullptr;
PCHAR Output = nullptr;
PCHAR Controllo = nullptr;

PCHAR NewS = nullptr;
PCHAR CloseS = nullptr;
PCHAR DataDS = nullptr;
PCHAR InputS = nullptr;
PCHAR OutputS = nullptr;
PCHAR ControlloS = nullptr;
PCHAR Est = (char*)".txt";
// Costruttore
Comunicazione(LPCSTR data)
{
size_t dataSize = strlen(data);
Data = new CHAR[dataSize + 1];
strcpy_s(Data, dataSize + 1, data);
size_t subFolderSize = strlen("\\New");
New = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(New, dataSize + subFolderSize + 1, data);
strcat_s(New, dataSize + subFolderSize + 1, "\\New");
subFolderSize = strlen("\\Close");
Close = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(Close, dataSize + subFolderSize + 1, data);
strcat_s(Close, dataSize + subFolderSize + 1, "\\Close");
subFolderSize = strlen("\\Data");
DataD = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(DataD, dataSize + subFolderSize + 1, data);
strcat_s(DataD, dataSize + subFolderSize + 1, "\\Data");
subFolderSize = strlen("\\Data\\Input");
Input = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(Input, dataSize + subFolderSize + 1, data);
strcat_s(Input, dataSize + subFolderSize + 1, "\\Data\\Input");
subFolderSize = strlen("\\Data\\Output");
Output = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(Output, dataSize + subFolderSize + 1, data);
strcat_s(Output, dataSize + subFolderSize + 1, "\\Data\\Output");
subFolderSize = strlen("\\Data\\Controllo");
Controllo = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(Controllo, dataSize + subFolderSize + 1, data);
strcat_s(Controllo, dataSize + subFolderSize + 1, "\\Data\\Controllo");
subFolderSize = strlen("\\New\\");
NewS = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(NewS, dataSize + subFolderSize + 1, data);
strcat_s(NewS, dataSize + subFolderSize + 1, "\\New\\");
subFolderSize = strlen("\\Close\\");
CloseS = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(CloseS, dataSize + subFolderSize + 1, data);
strcat_s(CloseS, dataSize + subFolderSize + 1, "\\Close\\");
subFolderSize = strlen("\\Data\\");
DataDS = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(DataDS, dataSize + subFolderSize + 1, data);
strcat_s(DataDS, dataSize + subFolderSize + 1, "\\Data\\");
subFolderSize = strlen("\\Data\\Input\\");
InputS = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(InputS, dataSize + subFolderSize + 1, data);
strcat_s(InputS, dataSize + subFolderSize + 1, "\\Data\\Input\\");
subFolderSize = strlen("\\Data\\Output\\");
OutputS = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(OutputS, dataSize + subFolderSize + 1, data);
strcat_s(OutputS, dataSize + subFolderSize + 1, "\\Data\\Output\\");
subFolderSize = strlen("\\Data\\Controllo\\");
ControlloS = new CHAR[dataSize + subFolderSize + 1];
strcpy_s(ControlloS, dataSize + subFolderSize + 1, data);
strcat_s(ControlloS, dataSize + subFolderSize + 1, "\\Data\\Controllo\\");
}
void DirectoryCleaningComunicazione() {
DirectoryCleaning(Data);
DirectoryCleaning(New);
DirectoryCleaning(Close);
DirectoryCleaning(DataD);
DirectoryCleaning(Input);
DirectoryCleaning(Output);
DirectoryCleaning(Controllo);
}
// Distruttore
~Comunicazione()
{
delete[] Data;
delete[] New;
delete[] Close;
delete[] DataD;
delete[] Input;
delete[] Output;
delete[] Controllo;
delete[] NewS;
delete[] CloseS;
delete[] DataDS;
delete[] InputS;
delete[] OutputS;
delete[] ControlloS;
}
};
struct PosizioneCursore
{
COORD PosCar;
COORD PosAtt;
void ApperndPosAttX(int X, int Y) {
PosAtt.X = X;
PosAtt.Y = Y;
}
void ApperndPosAttY(int Y, int X) {
PosAtt.Y = Y;
PosAtt.X = X;
}
void Cycliner() {
PosCar.X = NULL;
PosCar.Y = NULL;
PosAtt.X = NULL;
PosAtt.Y = NULL;
}
};
//CREATE_NO_WINDOW
HANDLE StartProcess(LPCWCH Process) {
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
if (!CreateProcessW(Process, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
cout << "CreateProcess failed " << GetLastError() << "." << endl;
return NULL;
}
CloseHandle(pi.hThread);
if (pi.hProcess == NULL || pi.hProcess == INVALID_HANDLE_VALUE) {
printf("Invalid process handle.\n");
return NULL;
}
return pi.hProcess;
}
// Funzione per controllare se un processo con un determinato PID è in esecuzione
bool IsProcessRunning(DWORD pid)
{
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (Process32First(snapshot, &entry) == TRUE)
{
while (Process32Next(snapshot, &entry) == TRUE)
{
if (entry.th32ProcessID == pid)
{
CloseHandle(snapshot);
return true;
}
}
}
CloseHandle(snapshot);
return false;
}
// Funzione per controllare se un processo figlio è in esecuzione sotto a un processo padre
bool IsChildProcessRunning(HANDLE hParentProcess, HANDLE hChildProcess)
{
DWORD parentPid = GetProcessId(hParentProcess);
DWORD childPid = GetProcessId(hChildProcess);
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (Process32First(snapshot, &entry) == TRUE)
{
while (Process32Next(snapshot, &entry) == TRUE)
{
if (entry.th32ParentProcessID == parentPid && entry.th32ProcessID == childPid)
{
CloseHandle(snapshot);
return IsProcessRunning(childPid);
}
}
}
CloseHandle(snapshot);
return false;
}
int GetFileSizeInKB(const char* filepath) {
WIN32_FILE_ATTRIBUTE_DATA fileInfo;
if (!GetFileAttributesExA(filepath, GetFileExInfoStandard, &fileInfo)) {
std::cerr << "Error: failed to get file attributes.\n";
return -1;
}
ULARGE_INTEGER size;
size.LowPart = fileInfo.nFileSizeLow;
size.HighPart = fileInfo.nFileSizeHigh;
return static_cast<int>(size.QuadPart);
}

char* CreateProcessControlPer(char* Per, int N_Pro, char* Est) {
char* Per_0 = new char[strlen(Per) + 1];
strcpy(Per_0, Per);
char* Per_1 = strcat(Per_0, (const char*)to_string(N_Pro).c_str());
char* Per_2 = strcat(Per_1, Est);
return Per_2;
}
void ControlProcess(char* Cont) {
FILE* Control = fopen(Cont, "w");
fclose(Control);
}
void StartProcess(char* Cont) {
FILE* Control = fopen(Cont, "w");
fclose(Control);
}
void CloseProcess(char* Cont) {
FILE* Control = fopen(Cont, "w");
fclose(Control);
}
char* ConCat(char* Cartella, char* File) {
char* CartellaNew = new char[strlen(Cartella) + 1];
strcpy(CartellaNew, Cartella);
char* ConCat = strcat(CartellaNew, File);
return ConCat;
}
bool ControlTF(int CileFor, int Sle, char* Per) {
for (int y = 0; y <= CileFor - 1; y++) {
Sleep(Sle);
if (GetFileSizeInKB(Per) != 0) {
y = CileFor;
return true;
}
}
return false;
}
void IDprocess(char* pach, int ID) {
FILE* File = fopen(pach, "w");
if (File != NULL) {
fprintf(File, to_string(ID).c_str());
fclose(File);
}
}
bool askUser(int TI, const char* TIC, int TS, const char* TSC) {
string input;
while (true) {
ColorText(TI, TIC);
ColorText(TS, TSC);
cin >> input;
if (input == "y" || input == "Y") {
return true;
}
else if (input == "n" || input == "N") {
return false;
}
}
}
bool SycurityUser(int TI, const char* TIC, const char* PAS) {
string input;
while (true) {
ColorText(TI, TIC);
cin >> input;
if (strcmp(input.c_str(), PAS) == 0) {
return true;
}
else {
return false;
}
}
}

// Esempio uso IsChildProcessRunning: IsChildProcessRunning(GetCurrentProcess(), Process.Coyn[0]);
HANDLE Start_Coyn() {
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
TCHAR szPath[] = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\x64\\Debug\\Traiding_C++.exe");
if (!CreateProcessW(szPath, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
printf("CreateProcess failed (%d).\n", GetLastError());
return NULL;
}
CloseHandle(pi.hThread);
if (pi.hProcess == NULL || pi.hProcess == INVALID_HANDLE_VALUE) {
printf("Invalid process handle.\n");
return NULL;
}
return pi.hProcess;
}
int main()
{
Process Process;
Process_Per(Process);
Comunicazione Comunicazione("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Data");
PosizioneCursore Posizione;
//Start_Coyn();
//StartProcess(Process.TraidingPer);
//system("pause");
int total = 203;
int progress = 0;
char* Start = NULL;
cout << "Preparazione del programma" << endl;
if (askUser(color::Verde, "Sicuro di voler far partire il programma? ", color::Verde, "(y/n) ")) {
Comunicazione.DirectoryCleaningComunicazione();
// Simula il caricamento
Posizione.Cycliner();
Posizione.PosCar = getxy();
Posizione.ApperndPosAttY(Posizione.PosCar.Y + 1, NULL);
while (!PrintProgressBar(progress, total, true, color::Green, color::Green, color::Fucsia, color::Bordeaux)) {
gotoxy(Posizione.PosAtt);
bool ExitStartProcess = true;
switch (progress)
{
case 0:
IDprocess(ConCat(Comunicazione.DataDS, (char*)"IDprocess.txt"), 0);
while (ExitStartProcess)
{
Process.Traiding = new HANDLE;
Process.Traiding[0] = StartProcess(Process.TraidingPer);
if (Process.Traiding[0] != NULL) {
ControlProcess(CreateProcessControlPer(Comunicazione.ControlloS, 0, ConCat(Process.TraidingCom, Comunicazione.Est)));
if (ControlTF(20, 1, CreateProcessControlPer(Comunicazione.ControlloS, 0, ConCat(Process.TraidingCom, Comunicazione.Est)))) {
Sleep(10);
ExitStartProcess = false;
Process.TraidingNum++;
progress++;
}
else {
TerminateProcess(Process.Traiding[0], 1);
DirectoryCleaning(Comunicazione.Controllo);
}
}
}
break;
case 1:
IDprocess(ConCat(Comunicazione.DataDS, (char*)"IDprocess.txt"), 0);
while (ExitStartProcess)
{
Process.ReturnCoyn = new HANDLE;
Process.ReturnCoyn[0] = StartProcess(Process.ReturnCoynPer);
if (Process.ReturnCoyn[0] != NULL) {
ControlProcess(CreateProcessControlPer(Comunicazione.ControlloS, 0, ConCat(Process.ReturnCoyngCom, Comunicazione.Est)));
if (ControlTF(20, 1, CreateProcessControlPer(Comunicazione.ControlloS, 0, ConCat(Process.ReturnCoyngCom, Comunicazione.Est)))) {
Sleep(10);
ExitStartProcess = false;
Process.ReturnCoynNum++;
progress++;
}
else {
TerminateProcess(Process.ReturnCoyn[0], 1);
DirectoryCleaning(Comunicazione.Controllo);
}
}
}
break;
case 2:
IDprocess(ConCat(Comunicazione.DataDS, (char*)"IDprocess.txt"), 0);
while (ExitStartProcess)
{
Process.DataCoyn = new HANDLE;
Process.DataCoyn[0] = StartProcess(Process.DataCoynPer);
if (Process.DataCoyn[0] != NULL) {
ControlProcess(CreateProcessControlPer(Comunicazione.ControlloS, 0, ConCat(Process.DataCoynCom, Comunicazione.Est)));
if (ControlTF(20, 1, CreateProcessControlPer(Comunicazione.ControlloS, 0, ConCat(Process.DataCoynCom, Comunicazione.Est)))) {
Sleep(10);
ExitStartProcess = false;
Process.DataCoynNum++;
progress++;
}
else {
TerminateProcess(Process.DataCoyn[0], 1);
DirectoryCleaning(Comunicazione.Controllo);
}
}
}
break;
default:
IDprocess(ConCat(Comunicazione.DataDS, (char*)"IDprocess.txt"), Process.CoynNum);
while (ExitStartProcess)
{
Process.Coyn = new HANDLE;
Process.Coyn[Process.CoynNum] = StartProcess(Process.CoynPer);
if (Process.Coyn[Process.CoynNum] != NULL) {
ControlProcess(CreateProcessControlPer(Comunicazione.ControlloS, Process.CoynNum, Comunicazione.Est));
if (ControlTF(20, 1, CreateProcessControlPer(Comunicazione.ControlloS, Process.CoynNum, Comunicazione.Est))) {
Sleep(10);
ExitStartProcess = false;
Process.CoynNum++;
progress++;
}
else {
TerminateProcess(Process.Coyn[Process.CoynNum], 1);
DirectoryCleaning(Comunicazione.Controllo);
}
}
}
break;
}
Posizione.PosAtt = getxy();
gotoxy(Posizione.PosCar);
}
gotoxy(Posizione.PosAtt);
Sleep(1000);
DirectoryCleaning(Comunicazione.Controllo);
cout << "Programma pronto per partire" << endl;
StartProcess(ConCat(Comunicazione.DataDS, (char*)"Start.txt"));
if (askUser(color::Verde, "Start Program? ", color::Verde, "(y/n) ")) {
StartProcess(ConCat(Comunicazione.DataDS, (char*)"Start.txt"));
/*(GetAsyncKeyState(VK_CONTROL) & 0x8000) &&
(GetAsyncKeyState('X') & 0x8000) &&
(GetAsyncKeyState(VK_SHIFT) & 0x8000)*/
}
else {
if (SycurityUser(color::Verde, "Sei sicuro di voler chiudere il programma, inserichi il PIN: ", "12345")) {
CloseProcess(ConCat(Comunicazione.CloseS, (char*)"Close.txt"));
progress = 0;
total + 1;
Posizione.Cycliner();
Posizione.PosCar = getxy();
Posizione.ApperndPosAttY(Posizione.PosCar.Y + 1, NULL);
while (!PrintProgressBar(progress, total, true, color::Green, color::Green, color::Fucsia, color::Bordeaux)) {
gotoxy(Posizione.PosAtt);
if (progress <= Process.CoynNum - 1) {
CloseProcess(CreateProcessControlPer(Comunicazione.CloseS, progress, Comunicazione.Est));
progress++;
}
else if (progress - Process.CoynNum <= Process.DataCoynNum - 1) {
CloseProcess(CreateProcessControlPer(Comunicazione.CloseS, progress - Process.CoynNum, ConCat(Process.DataCoynCom, Comunicazione.Est)));
progress++;
}
else if (progress - Process.CoynNum - Process.DataCoynNum <= Process.ReturnCoynNum - 1) {
CloseProcess(CreateProcessControlPer(Comunicazione.CloseS, progress - Process.CoynNum - Process.DataCoynNum, ConCat(Process.ReturnCoyngCom, Comunicazione.Est)));
progress++;
}
else if (progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum <= Process.TraidingNum - 1) {
CloseProcess(CreateProcessControlPer(Comunicazione.CloseS, progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum, ConCat(Process.TraidingCom, Comunicazione.Est)));
progress++;
}
else {
Sleep(5000);
progress++;
}
Posizione.PosAtt = getxy();
gotoxy(Posizione.PosCar);
}
gotoxy(Posizione.PosAtt);
total - 1;
progress = 0;
Posizione.Cycliner();
Posizione.PosCar = getxy();
Posizione.ApperndPosAttY(Posizione.PosCar.Y + 1, NULL);
while (!PrintProgressBar(progress, total, true, color::Green, color::Green, color::Fucsia, color::Bordeaux)) {
gotoxy(Posizione.PosAtt);
if (progress <= Process.CoynNum - 1) {
if (!ControlTF(10, 1, CreateProcessControlPer(Comunicazione.CloseS, progress, Comunicazione.Est))) {
Process.CoynError[Process.CoynErrorNum] = progress;
Process.CoynErrorNum++;
}
progress++;
}
else if (progress - Process.CoynNum <= Process.DataCoynNum - 1) {
if (!ControlTF(10, 1, CreateProcessControlPer(Comunicazione.CloseS, progress - Process.CoynNum, ConCat(Process.DataCoynCom, Comunicazione.Est)))) {
Process.DataCoynError[Process.DataCoynErrorNum] = progress;
Process.DataCoynErrorNum++;
}
progress++;
}
else if (progress - Process.CoynNum - Process.DataCoynNum <= Process.ReturnCoynNum - 1) {
if (!ControlTF(10, 1, CreateProcessControlPer(Comunicazione.CloseS, progress - Process.CoynNum - Process.DataCoynNum, ConCat(Process.ReturnCoyngCom, Comunicazione.Est)))) {
Process.ReturnCoynError[Process.ReturnCoynErrorNum] = progress;
Process.ReturnCoynErrorNum++;
}
progress++;
}
else if (progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum <= Process.TraidingNum - 1) {
if (!ControlTF(500, 10, CreateProcessControlPer(Comunicazione.CloseS, progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum, ConCat(Process.TraidingCom, Comunicazione.Est)))) {
Process.TraidingError[Process.TraidingErrorNum] = progress;
Process.TraidingErrorNum++;
}
progress++;
}
else {
}
Posizione.PosAtt = getxy();
gotoxy(Posizione.PosCar);
}
gotoxy(Posizione.PosAtt);
total = Process.CoynErrorNum + Process.DataCoynErrorNum + Process.ReturnCoynErrorNum + Process.TraidingErrorNum;
progress = 0;
if (total != 0) {
ColorText(color::Red, "Errore Terminate Process, Avvio ciusura FORZATA ");
cout << endl;
Posizione.Cycliner();
Posizione.PosCar = getxy();
Posizione.ApperndPosAttY(Posizione.PosCar.Y + 1, NULL);
while (!PrintProgressBar(progress, total, true, color::Green, color::Green, color::Fucsia, color::Bordeaux)) {
gotoxy(Posizione.PosAtt);
if (progress <= Process.CoynNum - 1 && Process.CoynNum != 0) {
if (TerminateProcess(Process.Coyn[Process.CoynError[progress]], 1)) {
ColorTextSet(color::Verde);
cout << "Processo 'COYN' Num -> " << Process.CoynError[progress] << " <- Terminato.";
ColorTextSet(color::Bianco);
}
else {
ColorTextSet(color::Bordeaux);
cout << "ERROR " << GetLastError() << ": Impossibile terminare il processo";
ColorTextSet(color::Bianco);
}
progress++;
}
else if (progress - Process.CoynNum <= Process.DataCoynNum - 1 && Process.DataCoynNum != 0) {
if (TerminateProcess(Process.DataCoyn[Process.DataCoynError[progress - Process.CoynNum]], 1)) {
ColorTextSet(color::Verde);
cout << "Processo 'DATACOYN' Num -> " << Process.DataCoynError[progress - Process.CoynNum] << " <- Terminato.";
ColorTextSet(color::Bianco);
}
else {
ColorTextSet(color::Bordeaux);
cout << "ERROR " << GetLastError() << ": Impossibile terminare il processo";
ColorTextSet(color::Bianco);
}
progress++;
}
else if (progress - Process.CoynNum - Process.DataCoynNum <= Process.ReturnCoynNum - 1 && Process.ReturnCoynNum != 0) {
if (TerminateProcess(Process.ReturnCoyn[Process.ReturnCoynError[progress - Process.CoynNum - Process.DataCoynNum]], 1)) {
ColorTextSet(color::Verde);
cout << "Processo 'RETURNCOYN' Num -> " << Process.ReturnCoynError[progress - Process.CoynNum - Process.DataCoynNum] << " <- Terminato.";
ColorTextSet(color::Bianco);
}
else {
ColorTextSet(color::Bordeaux);
cout << "ERROR " << GetLastError() << ": Impossibile terminare il processo";
ColorTextSet(color::Bianco);
}
progress++;
}
else if (progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum <= Process.TraidingNum - 1 && Process.TraidingNum != 0) {
if (TerminateProcess(Process.Traiding[Process.TraidingError[progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum]], 1)) {
ColorTextSet(color::Verde);
cout << "Processo 'TRAIDING' Num -> " << Process.TraidingError[progress - Process.CoynNum - Process.DataCoynNum - Process.ReturnCoynNum] << " <- Terminato.";
ColorTextSet(color::Bianco);
}
else {
ColorTextSet(color::Bordeaux);
cout << "ERROR " << GetLastError() << ": Impossibile terminare il processo";
ColorTextSet(color::Bianco);
}
progress++;
}
else {
}
Posizione.PosAtt = getxy();
gotoxy(Posizione.PosCar);
}
gotoxy(Posizione.PosAtt);
}
Process.Process_Free();
Comunicazione.~Comunicazione();
}
}
}
else {
Process.Process_Free();
Comunicazione.~Comunicazione();
}
system("pause");
//return 0;
}
M
MagoMiratempo
Pochi posts
Iscritto da
feb, 2023
Messaggi:
30
Re: Errore con la memora Heap
15 mar 2023, 19:47
Scusate in anticipo per il codice che non l'ho messo nel tag ma non me lo caricava

MagoMiratempo

Pochi posts

Iscritto da: feb, 2023

Messaggi:: 30

Re: Errore con la memora Heap

15 mar 2023, 19:49

Grafica.h:

#include "Librari_Standard.h"

/*
0   = Nero
1   = Blu scuro
2   = Verde
3   = Verde acqua
4   = Bordeaux
5   = Viola
6   = Verde oliva
7   = Grigio chiaro
8   = Grigio
9   = Blu
10 = Verde limone  (A)
11 = Azzurro            (B)
12 = Rosso               (C)
13 = Fucsia              (D)
14 = Giallo                (E)
15 = Bianco              (F)
*/

#define NERO		0 
#define BLUS		1
#define VERDE		2
#define VERDEACQ	3
#define BORDEAUX	4
#define VIOLA		5
#define VIOLAOLI	6
#define GRIGIOCHI	7
#define GRIGIO		8
#define BLU			9
#define VERDELIM	10
#define AZZURRO		11
#define ROSSO		12
#define FUCSIA		13
#define GIALLO		14
#define BIANCO		15

#define BLACK		NERO
#define GREEN		VERDE
#define RED			ROSSO

#ifndef GRAFICA_H
#define GRAFICA_H

namespace Grafica {

	class color {
		public:
			static const WORD Nero = NERO;
			static const WORD Blus = BLUS;
			static const WORD Verde = VERDE;
			static const WORD Verdeacq = VERDEACQ;
			static const WORD Bordeaux = BORDEAUX;
			static const WORD Viola = VIOLA;
			static const WORD Violaoli = VIOLAOLI;
			static const WORD Grigiochi = GRIGIOCHI;
			static const WORD Grigio = GRIGIO;
			static const WORD Blu = BLU;
			static const WORD Verdelim = VERDELIM;
			static const WORD Azzurro = AZZURRO;
			static const WORD Rosso = ROSSO;
			static const WORD Fucsia = FUCSIA;
			static const WORD Giallo = GIALLO;
			static const WORD Bianco = BIANCO;

			static const WORD Black = BLACK;
			static const WORD Green = GREEN;
			static const WORD Red = RED;
	};

	COORD getxy();
	void gotoxy(COORD coordinates);

	void ColorTextSet(int x);
	//int SetColorText = 0;

	//void ColorText(const char* Text);
	void ColorText(int x, const char* Text);
	void ColorText(int x, const char* Text, const char* Text2);

	bool PrintProgressBar(double progress, double total, WORD colorU);
	bool PrintProgressBar(double progress, double total, WORD colorU, WORD colorP);
	bool PrintProgressBar(double progress, double total, WORD colorU, WORD colorP, WORD colorN);

	bool PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU);
	bool PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU, WORD colorP);
	bool PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU, WORD colorP, WORD colorN);
}
//#include "Grafica.cpp"
#endif

MagoMiratempo

Pochi posts

Iscritto da: feb, 2023

Messaggi:: 30

Re: Errore con la memora Heap

15 mar 2023, 19:50

Grafica.cpp

#include "Librari_Standard.h"

#include "Grafica.h"

#ifndef GRAFICA_CPP
#define GRAFICA_CPP


COORD Grafica::getxy() {
    CONSOLE_SCREEN_BUFFER_INFO buff;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &buff);
    /* info disponibili:
    dwCursorPosition     COORD
    dwMaximumWindowSize  COORD
    dwSize               COORD
    srWindow             SMALL_RECT
    wAttributes          WORD
    */
    return buff.dwCursorPosition;
}

void Grafica::gotoxy(COORD coordinates)
{
    SetConsoleCursorPosition(
        GetStdHandle(STD_OUTPUT_HANDLE), coordinates);
}

void Grafica::ColorTextSet(int x) {
	HANDLE hCon;
	hCon = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hCon, x);
}

void Grafica::ColorText(int x, const char* Text) {
	HANDLE hCon;
	hCon = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hCon, x);

	printf(Text);
	hCon = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hCon, 15);
}

void Grafica::ColorText(int x, const char* Text, const char* Text2) {
	Grafica::ColorText(x, Text);
	Grafica::ColorText(x, Text2);
}

/*
void Grafica::ColorText(const char* Text) {
	Grafica::ColorText(Grafica::SetColorText, Text);
}*/

bool Grafica::PrintProgressBar(double progress, double total, WORD colorU)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    std::cout << "] " << static_cast<int>(percent) << "%" << std::flush; // Aggiungi flush per svuotare il buffer di output

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

bool Grafica::PrintProgressBar(double progress, double total, WORD colorU, WORD colorP)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }
    
    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << "] ";

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    std::cout << static_cast<int>(percent) << "%" << std::flush; // Aggiungi flush per svuotare il buffer di output

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

bool Grafica::PrintProgressBar(double progress, double total, WORD colorU, WORD colorP, WORD colorN)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }

    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << "] ";

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorN);
    std::cout << static_cast<int>(percent) << "%" << std::flush; // Aggiungi flush per svuotare il buffer di output
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

bool Grafica::PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    std::cout << "] " << static_cast<int>(percent) << "%"; // Aggiungi flush per svuotare il buffer di output

    if (DaA) {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorPRO);
        std::cout << " " << static_cast<int>(progress) << "\\" << static_cast<int>(total) << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }
    else {
        std::cout << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

bool Grafica::PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU, WORD colorP)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }

    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << "] ";
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    std::cout << static_cast<int>(percent) << "%"; // Aggiungi flush per svuotare il buffer di output

    if (DaA) {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorPRO);
        std::cout << " " << static_cast<int>(progress) << "\\" << static_cast<int>(total) << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }
    else {
        std::cout << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

bool Grafica::PrintProgressBar(double progress, double total, bool DaA, WORD colorPRO, WORD colorU, WORD colorP, WORD colorN)
{
    const int barWidth = 50;
    const char completeChar = '=';
    const char incompleteChar = ' ';

    // Calcola la percentuale di completamento
    double percent = progress / total * 100.0;

    // Calcola il numero di caratteri completi e incompleti
    int completeChars = static_cast<int>(percent / 100.0 * barWidth);
    int incompleteChars = barWidth - completeChars;

    // Stampa la barra di caricamento
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << '[';
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorU);

    for (int i = 0; i < completeChars; ++i) {
        std::cout << completeChar;
    }

    for (int i = 0; i < incompleteChars; ++i) {
        std::cout << incompleteChar;
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorP);
    std::cout << "] ";

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorN);
    std::cout << static_cast<int>(percent) << "%"; // Aggiungi flush per svuotare il buffer di output
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);

    if (DaA) {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colorPRO);
        std::cout << " " << static_cast<int>(progress) << "\\" << static_cast<int>(total) << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }
    else {
        std::cout << std::flush;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }

    // Restituisce true se il caricamento è completo
    if (progress >= total) {
        std::cout << std::endl; // Vai a capo dopo il completamento
        return true;
    }

    std::cout << "\r"; // Sposta il cursore all'inizio della riga per sovrascrivere la stampa precedente
    return false;
}

#endif

O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21265
Re: Errore con la memora Heap
15 mar 2023, 20:17
Partiamo dal fatto che non ho ancora capito cosa vuoi fare con questo tuo programma e tu non l'hai mai detto chiaramente.
Inoltre non ho alcuna intenzione di creare i progetti e copiare tutto il codice sorgente che hai sparso qui, senza neanche conoscere le relazioni tra le varie parti e l'obiettivo finale.
Forse impiegherei qualche decina di minuti a provare il tutto solo se dicessi chiaramente a che serve e mettessi a disposizione tutto il progetto con tutti i file zippati da testare.
M
MagoMiratempo
Pochi posts
Iscritto da
feb, 2023
Messaggi:
30
Re: Errore con la memora Heap
15 mar 2023, 20:57
Hai perfettamente ragione. Quindi il programma avvia tre programmi, e un quarto programma se specificato. Questo programma è solo un programma di controllo e comando per gestire eventuali errori e, se necessario, chiudere il programma forzatamente. Il programma finale serve invece per aumentare la velocità di calcolo in parallelo di più dati e formulare una risposta corretta. Finora, il codice che ho scritto è quasi completo. Tuttavia, se lo eseguissi sul tuo computer, non funzionerebbe e ti restituirebbe solo una marea di errori. Per farlo funzionare, dovresti:
1: Dovresti cambiare i percorsi qui:
```
Process.TraidingPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\x64\\Debug\\Traiding_C++.exe");
   Process.ReturnCoynPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Return_Coyn\\x64\\Debug\\Return_Coyn.exe");
   Process.DataCoynPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Data_Coyn\\x64\\Debug\\Data_Coyn.exe");
   Process.CoynPer = TEXT("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Coyn\\x64\\Debug\\Coyn.exe");
```
Questi sono i 4 file da eseguire.
2 Dovresti cambiare i percorsi qui:
```
Comunicazione Comunicazione("C:\\Users\\alext\\Desktop\\Traiding_C++\\Traiding_C++\\Data");
```
Questa è la carella che usa il programma per la comunicazione.
3:
Una volta eseguito il programma ti chiede se vuoi farlo partire oppure no, y ? si, n ? no.
Partirà una sorta di caricamento che indica l'avanzamento di partenza dei programmi ( Quando finisce il caricamento vuol dire che a fatto partire tutti i programmi )
4:
Quando ha finito il caricamento ti verrà fuori una seconda domanda y ? si, n ? no. ( y non è ancora stata costruita )
5:
Una volta eseguito il comando n, il programma richiederà una conferma di uscita e sarà necessario digitare “12345”
PS.
MOLTO IMPORTANTE bisogna cambiare il valore di:
```
int total = 203;
```
Senno fare partire 203 programmi.
PSS.
Mi raccomando, non chiudere mai il programma con la X o forzatamente, a meno che non sia assolutamente necessario in caso di emergenza. In caso contrario, sarà necessario chiudere manualmente tutti i programmi, il che può essere molto fastidioso.
M
MagoMiratempo
Pochi posts
Iscritto da
feb, 2023
Messaggi:
30
Re: Errore con la memora Heap
15 mar 2023, 20:59
La funzione sha256 non è inerente al codice è una funzione per criptare in HASH

Devi accedere o registrarti per scrivere nel forum

11 risposte