Array valori sbagliati

di Marchetto il
16 risposte

Int red[4][3];

red[0][0] = 244; red[0][1] = 12; red[0][2] = 12;

red[1][0] = 211; red[0][1] = 21; red[0][2] = 21;

red[2][0] = 183; red[0][1] = 45; red[0][2] = 45;

red[3][0] = 211; red[0][1] = 67; red[0][2] = 67;

se faccio sizeof(red) mi restituisce 48

grazie.

16 Risposte

  • Se vuoi 12 devi fare sizeof(red)/sizeof(int)

  • Io voglio 4 la lunghezza di red[]

  • Ti stai approcciando al problema in modo SBAGLIATO!

    Il C (perche' tu stai usando la sintassi del C) NON E' un linguaggi di programmazione molto evoluto. 
    E' solo un epsilon piu' astratto dell'assembler. 
    MA poiche' e' nato nel 1972, a quel tempo i linguaggi di programmazione erano mooooolto piu' primitivi di oggi.

    Questo per dire che la gestione degli array fondamentalmente NON ESISTE. Per il C un array di QUALUNQUE dimensione e' semplicemente un blocco di memoria sul quale, grasso che cola, si possono fare alcune operazioni LEGATE al support fornito dal linguaggio macchina E dal compilator. 

    Quindi, se ti servono le dimensioni dell'array, la soluzione migliore e “standard” e' passarle come parametro.

  • Io stò usando c++

    sizeof è del c?

  • 17/11/2023 - Weierstrass ha scritto:


    Io voglio 4 la lunghezza di red[]

    Che vuol dire “la lunghezza di red”? E' un array … intendi la prima dimensione?

    sizeof è C 

  • Non serve a niente ma puoi fare così

    #include "stdio.h"
    
    #define COLUMNS(x) (sizeof(x[0])/sizeof(x[0][0]))
    #define ROWS(x)    (sizeof(x)/sizeof(typeof(x[0][0]))/COLUMNS(x))   
    
    
    int main(){
        int red[5][7];
        int colonne = COLUMNS(red);
        int righe = ROWS(red);
        printf("[%d][%d]", righe, colonne);
    
        return 0;
    }
  • In C++ è così

    #include <cstdlib>
    #include <iostream>
    
    #define typeof(x) __typeof__(x)
    
    #define COLUMNS(x) (sizeof(x[0])/sizeof(x[0][0]))
    #define ROWS(x)    (sizeof(x)/sizeof(typeof(x[0][0]))/COLUMNS(x))   
    
    
    int main(){
        int red[5][7];
        int colonne = COLUMNS(red);
        int righe = ROWS(red);
        printf("[%d][%d]", righe, colonne);
    
        return 0;
    }
  • Salve

    qui c'è un errore di indici.

    red[0][0] = 244; red[0][1] = 12; red[0][2] = 12;

    red[1][0] = 211; red[ 0 ][1] = 21; red[ 0 ][2] = 21; << - - errore indice di colonna 

    red[1][0 ] = 211; red[ 1 ][1] = 21; red[ 1 ][2] = 21;

    red[2][0] = 183; red[0][1] = 45; red[0][2] = 45; << - - errore indice colonna 

    red[2][0] = 183; red[ 2 ][1] = 45; red[ 2 ][2] = 45;

    red[3][0] = 211; red[ 0 ][1] = 67; red[ 0 ][2] = 67; << - - errore indice colonna 

    red[3][0] = 211; red[ 3 ][1] = 67; red[ 3 ][2] = 67;

    #include <iostream>
    using namespace std;
    int main() {
        
        const int row = 3;
        const int col = 4;
        int red[col][row];
        red[0][0] = 244; red[0][1] = 12; red[0][2] = 12;
        red[1][0] = 211; red[1][1] = 21; red[1][2] = 21;
        red[2][0] = 183; red[2][1] = 45; red[2][2] = 45;
        red[3][0] = 211; red[3][1] = 67; red[3][2] = 67;
        cout << "num of col. : " << sizeof(red) / row / sizeof(int) << endl; 
        return 0;
    }

    Ti do' una dritta : non scrivere mai le dimensione degli array a numeri ma usa delle costanti

    cont int row=3;

    oppure

    #define ROW (3)
  • 29/11/2023 - LukeSkyWalker ha scritto:


    Salve

    qui c'è un errore di indici.

    red[0][0] = 244; red[0][1] = 12; red[0][2] = 12;

    red[1][0] = 211; red[ 0 ][1] = 21; red[ 0 ][2] = 21; << - - errore indice di colonna 

    red[1][0 ] = 211; red[ 1 ][1] = 21; red[ 1 ][2] = 21;

    red[2][0] = 183; red[0][1] = 45; red[0][2] = 45; << - - errore indice colonna 

    red[2][0] = 183; red[ 2 ][1] = 45; red[ 2 ][2] = 45;

    red[3][0] = 211; red[ 0 ][1] = 67; red[ 0 ][2] = 67; << - - errore indice colonna 

    red[3][0] = 211; red[ 3 ][1] = 67; red[ 3 ][2] = 67;

    #include <iostream>
    using namespace std;
    int main() {
        
        const int row = 3;
        const int col = 4;
        int red[col][row];
        red[0][0] = 244; red[0][1] = 12; red[0][2] = 12;
        red[1][0] = 211; red[1][1] = 21; red[1][2] = 21;
        red[2][0] = 183; red[2][1] = 45; red[2][2] = 45;
        red[3][0] = 211; red[3][1] = 67; red[3][2] = 67;
        cout << "num of col. : " << sizeof(red) / row / sizeof(int) << endl; 
        return 0;
    }

    Ti do' una dritta : non scrivere mai le dimensione degli array a numeri ma usa delle costanti

    cont int row=3;

    oppure

    #define ROW (3)

    Rilegenndo questo post mi sa' che ho invertito righe con le colonne :D ,

    cmq  il bug rimane lo stesso errore degli indici.

    #include <iostream>
    using namespace std;
    int main() {    
        const int row = 4;
        const int col = 3;
        int red[row][col];
        red[0][0] = 244; red[0][1] = 12; red[0][2] = 12;
        red[1][0] = 211; red[1][1] = 21; red[1][2] = 21;
        red[2][0] = 183; red[2][1] = 45; red[2][2] = 45;
        red[3][0] = 211; red[3][1] = 67; red[3][2] = 67;
        cout << "num of col. : " << sizeof(red) / row / sizeof(int) << endl; 
        return 0;
    }

    Ti do' una dritta : non scrivere mai le dimensione degli array a numeri ma usa delle costanti

    cont int col=3;

    oppure

    #define COLUMNS (3)
  • Che topic surreale!

    Comunque penso che la risposta più concisa all'OP (la cui ultima visita risale quasi ad un mese fa) sia la seguente:

    #include <stdio.h>
    
    int main()
    {
        int m[4][3];
        printf("%u\n", sizeof(m) / sizeof(*m));
    }

    31/12/2023 - LukeSkyWalker ha scritto:


    #define COLUMNS (3)

    Utilizzare le parentesi per una macro costituita da un singolo numero ha un'utilità precisa oppure si tratta di abitudini di “buona programmazione”?

  • Utilizzare le parentesi per una macro costituita da un singolo numero ha un'utilità precisa oppure si tratta di abitudini di “buona programmazione”?

    sono sincero non me lo ricordo più :D 

    c'è una utilità ben precisa, 

    tanto tempo fa' non le usavo poi mi sono imbattuto in un problema che ho risolto mettendo le parentesi

    probabilemente avevo qualcosa tipo 

    #define PLUTO 2
    #define PIPPO 30+PLUTO
    .....
    
    int ret = PIPPO * 2 ;   // risultato 34 invece di 64
    
    
    #define PLUTO 2
    #define PIPPO (30+PLUTO)
    .....
    
    int ret = PIPPO * 2 ;   // risultato 64
    

    oppure avevo problema con qualche cast da float a intero o viceversa ( questo non ne sono sicuro)

    #define PIPPO (2.0)
    ...
    
    int  = PIPPO / 3;

    cmq di una cosa sono certo :

    che è un modo per forzare il compilatore che quel define è un valore numerico, di qualsiasi tipo (signed,int,float.etc.) ma numerico. 

    se riesco a trovare il caso specifico che avevo risolto ti faccio sapere.

  • 31/12/2023 - Nippolo ha scritto:

    31/12/2023 - LukeSkyWalker ha scritto:


    #define COLUMNS (3)

    Utilizzare le parentesi per una macro costituita da un singolo numero ha un'utilità precisa oppure si tratta di abitudini di “buona programmazione”?

    Ha una sua utilità se ci sono più valori e/o variabili, certamente.

    Nell'esempio riportato da LukeSkyWalker:

    #define PLUTO 2
    #define PIPPO 30+PLUTO
    .....
    
    int ret = PIPPO * 2 ;   // risultato 34 invece di 64

    il compilatore sostituisce a PIPPO il valore 30+PLUTO e quindi è come scrivere:

    int ret = 30+PLUTO*2 ;   // quindi il risultato è 34

    Invece nel secondo caso si ottiene:

    #define PLUTO 2
    #define PIPPO (30+PLUTO)
    .....
    int ret = PIPPO * 2 ;   // risultato 64
    
    // dato che il compilatore vede questo:
    
    int ret = (30+PLUTO) * 2 ;   // risultato 64

    Esattamente come insegnato in algebra :)

  • euscar quello che dici è corretto 

    ma c'era anche un altro motivo legato ai numeri , in particolare quelli decimali

    sicuramente era un forzatura al precompilatore dicendogli che è un valore numerico , 

    appena mi viene in mente,  ve lo dico , promesso ;D

  • Il motivo per cui ottieni 48 e non 12 è che sizeOf restituisce la dimensione in byte del tipo:

    sizeof( type )


    Yields the size in bytes of the object representation of type.

    Sulla tua piattaforma int apparentemente corrisponde a 4 bytes, 4 x 12  = 48

    17/11/2023 - Marchetto ha scritto:


    Io stò usando c++

    Allora usa le feature di C++:

    • Invece di usare un "raw array" definisci una classe specifica.
    • Utilizza le strutture dati offerte da C++ come std::vector che permettono una facile gestione della memoria pur essendo dinamiche. 
    • E sopratutto definisci un'interfaccia pubblica minima che si adatti ai tuoi requisiti.
    class Matrix {
    private:
        int rows;
        int cols;
        std::vector<int> data;
    
    public:
        Matrix(int rows, int cols) : rows(rows), cols(cols), data(rows * cols, 0) {}
    
        int getElement(int row, int col) const {
            return data[row * cols + col];
        }
    
        void setElement(int row, int col, int value) { //Solo se ti serve
            data[row * cols + col] = value;
        }
    
        int getNumberOfElements() const {
            return rows * cols;
        }
    };
    

    Questo ti permette di:

    • Riutilizzare facilmente la funzionalità implementata
    • Cambiare facilmente l'implementazione senza modificare il codice che lo usa (se non cambi l'interfaccia pubblica)
    • Testare facilmente le funzionalità implementate senza avere dipendenze sul codice più ad alto livello

    E se vuoi essere fancy puoi anche aggiungere un costruttore che accetta initialization lists per poter inizializzare i tuoi dati in maniera compatta e pulita:

    class Matrix {
        [...]
        
        Matrix(int rows, int cols, std::initializer_list<int> values)
            : rows(rows), cols(cols), data(rows * cols, 0) {
            auto it = values.begin();
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    if (it != values.end()) {
                        setElement(i, j, *it);
                        ++it;
                    }
                }
            }
        }
    
    };
    
    int main() {
        Matrix red(4, 3, {
            1, 1, 1,
            1, 1, 1,
            1, 1, 1,
            1, 1, 1
        });
    
        std::cout << "Numero di elementi: " << red.getNumberOfElements() << std::endl;
        return 0;
    }

    Ovvio che se vuoi il numero di colonne o di righe, basta esporre allo stesso modo i 2 valori.

Devi accedere o registrarti per scrivere nel forum
16 risposte