PROBLEMA visual studio code alcuni messaggi.

Pubblicità
Unable to open 'strlen.S': Unable to read file '/build/glibc-S9d2JN/glibc-2.27/sysdeps/x86_64/strlen.S' (Error: Unable to resolve non-existing file '/build/glibc-S9d2JN/glibc-2.27/sysdeps/x86_64/strlen.S').
Clicca per espandere...

Ho risolto questi problemi in questo modo:
Bash: 
cd /
mkdir build
sudo mkdir glibc-S9d2JN
cd glibc-S9d2JN/
sudo wget http://ftp.gnu.org/gnu/glibc/glibc-2.27.tar.gz
sudo tar -xzvf glibc-2.27.tar.gz

Ora mi prende tutti i file della libreria.
 
Niente da fare. Sapete darmi una dritta.​

In C non riesco a ridimensionare con i puntatori un array di int multidimensionale ROW*COLUMN.
Vorrei in pratica che l'array dinamico quindi creato con la malloc, possa passare da 3 ROW e 5 COLUMN di elementi a 6 ROW e 7 COLUMN elementi int.
 
Che codice hai scritto?
In sostanza devi fare una realloc per le righe e poi in un ciclo le realloc per le colonne. In pratica è la stessa logica che usi per allocare la memoria quando crei la matrice.
 
C: 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>


#define ROW 2
#define COLUMN 4


int main()
{
    int size,i,l,t,e;


    int rows = 2;
    int cols = 5;
    int chars = 20;


    int newrows;
    char ***table = malloc(rows * sizeof(char **));
    //alloco le righe
    for (i = 0; i < rows; i++)
        table[i] = malloc(cols * sizeof(char *));


    //alloco ogni cella riga-colonna
    for(i = 0; i < rows; i++)
        for(l = 0; l < cols; l++)
            table[i][l] = malloc(sizeof(char));


    strcpy(table[0][0],"00");
    strcpy(table[0][0],"00");
    strcpy(table[0][1],"01");
    strcpy(table[0][2],"02");
    strcpy(table[0][3],"03");
    strcpy(table[0][4],"04");
    strcpy(table[1][0],"10");
    strcpy(table[1][1],"11");
    strcpy(table[1][2],"12");
    strcpy(table[1][3],"13");
    strcpy(table[1][4],"14");
    //strcpy(table[2][0],"14"); //se decoentata va in errore di spazio seg fault


    for (i = 0; i < rows; i++)
        for(l=0;l< cols; l++)
        {
            if( (cols - 1) == l)
                printf("%s\t\n",table[i][l]);
            else
                printf("%s\t",table[i][l]);
        }


    newrows = rows + 3;
    //aumento il numero di righe
    table = realloc(table,newrows * sizeof(char **));

    table[2][0] = "01234567890123456789"; //DOVREBBE NON ANDARE IN ERRORE perchè ce piu spazio
    printf("caratteri: %s\n",table[0][0]);
    printf("Hello world!\n");
    return 0;
}
 
Non è una matrice di interi quindi, è una matrice di char.

Comunque:
C: 
    table = realloc(table,newrows * sizeof(char **));

    table[2][0] = "01234567890123456789"; //DOVREBBE NON ANDARE IN ERRORE perchè ce piu spazio

darà errore sicuramente, in quanto non hai allocato memoria per table[2]. Devi fare una malloc su questo elemento quindi.

C: 
    table = realloc(table,newrows * sizeof(char**));
    table[2] = malloc( cols*sizeof(char*));
    
    for(int i=0; i<cols; i++)
        table[2][i] = "01234567890123456789";

rifacendo il ciclo che hai usato tu, ma con rows+1, ottieni:
Codice: 
00      01      02      03      04
10      11      12      13      14
00      01      02      03      04
10      11      12      13      14
01234567890123456789    01234567890123456789    01234567890123456789    01234567890123456789    01234567890123456789

Hello world!
 
A ma non dovrebbe farlo la realloc? Se realloco la memoria per le righe forse non è detto che alloc la memoria per la singola riga.
Quindi i puntatori alle colonne non modifica la dimensione.

grazie, ci sto mettendo delle ore per capire tutti i concetti e come si è notato di creare la fantomatica tabella dinamica intanto di stringhe in tutti i campi.

Inviato da BLN-L21 tramite App ufficiale di Tom\'s Hardware Italia Forum
--- i due messaggi sono stati uniti ---
Altro dubbio: ma la calloc dovrebbe inizializzare a 0 i campi. Come mai non lo fa?
Ho riciclato tutta la tabella per allocare la memoria che era gia stata precedentemente allocata ma i vecchi valori rimangono.
C: 
[CENTER]*
*
*[/CENTER]
table = realloc(table,newrows * sizeof(char **));
    table[2] = malloc(cols * sizeof(char*));
    table[3] = malloc(cols * sizeof(char*));

    for(i = 0; i < newrows; i++)
        table[i] = calloc(1,cols *sizeof(char*));

    for (i = 0; i < rows; i++)
        for(l=0;l< cols; l++)
        {
            if( (cols - 1) == l)
                printf("%s\t\n",table[i][l]);
            else
                printf("%s\t",table[i][l]);
        }
 
Ultima modifica:
Non ho capito che hai fatto... secondo me dovresti fare qualcosa di semplice e comprendere le basi, perchè stai solo continuando ad aggiungere cose senza prenderti i dovuti tempi.

Le 2 malloc che fai allocano della memoria, poi fai un nuovo ciclo e allochi altra memoria. Perchè? Se vuoi allocare memoria per le righe in più, stai sbagliando, in quanto accedi a righe già allocate sicuramente in precedenza.

Inoltre stai anche sbagliando la sintassi della calloc: il primo argomento è il numero di elementi, il secondo la dimensione di ogni singolo elemento. Non devi moltiplicare tu per ottenere i bytes totali, come fai con malloc (https://www.cplusplus.com/reference/cstdlib/calloc/).

Ho modificato un pò il tuo esempio:
C: 
    int newrows = 2;
    //aumento il numero di righe
    table = realloc(table,(rows + newrows) * sizeof(char**));

    for(int i=rows; i < (newrows+rows); i++)
        table[i] = calloc( cols,sizeof(char*));
    
    table[2][0] = "01234567890123456789"; 
    table[2][4] = "01234567890123456789";     
    
    table[3][1] = "01234567890123456789"; 
    table[3][2] = "01234567890123456789"; 
    
    for (i = 0; i < rows+newrows; i++) 
    {
        for(l=0;l< cols; l++)
        {
            if( (cols - 1) == l)
                printf("%s\t\n",table[i][l]);
            else
                printf("%s\t",table[i][l]);
        }
    }
    
    printf("Hello world!\n");

Output:
Codice: 
00      01      02      03      04
10      11      12      13      14
00      01      02      03      04
10      11      12      13      14
01234567890123456789    (null)  (null)  (null)  01234567890123456789
(null)  01234567890123456789    01234567890123456789    (null)  (null)
Hello world!


Ps. sarebbe inoltre meglio fare un check su cosa ti viene restituito da calloc/malloc/realloc, poichè non è detto che l'allocazione vada a buon fine.

PPS. anche se al termine del programma la memoria viene rilasciata, è buona norma utilizzare anche i free (specie se è un programma che rimane in esecuzione a lungo).
 
DispatchCode ha detto:
Le 2 malloc che fai allocano della memoria, poi fai un nuovo ciclo e allochi altra memoria. Perchè? Se vuoi allocare memoria per le righe in più, stai sbagliando, in quanto accedi a righe già allocate sicuramente in precedenza.
Clicca per espandere...
Cio che volevo sapere. Scusa. sto sperimentando. Era per sapere come si comporta.
La calloc dovrebbe reinizializzare a 0 le variabili anche le stringhe e non lo fa. Ci guardo meglio.

ci metto anche i controlli NULL se alloca correttamente e free per liberare la memoria. grazie dell'aiuto @DispatchCode controcambio quando potrò. Buona giornata.
 
Pubblicità
Pubblicità
Indietro
Top