Newsgroup: it.hobby.elettronica.digitale
Titolo: array[] come paramentro,quanto spazio alloco in questi casi?

unsigned int ModRTU_CRC(unsigned char buf_Modbus_cmd[ ] , int len)
{
  ...
  ...
}
 
in pratica passo un puntatore a unsigned char o alloco spazio nello stack?
immagino la prima
 
chiedo conferma
 
grazie 
 
 

 ha scritto nel messaggio 
news:k39tuu$av9$1...@speranza.aioe.org...

a volte si chiede anche l'ovvio,come mi pare confermi 
http://www.eskimo.com/~scs/cclass/notes/sx10f.html
 
The answer is that the C compiler does a little something behind your back. 
It knows that whenever you mention an array name in an expression, it (the 
compiler) generates a pointer to the array's first element. Therefore, it 
knows that a function can never actually receive an array as a parameter. 
Therefore, whenever it sees you defining a function that seems to accept an 
array as a parameter, the compiler quietly pretends that you had declared it 
as accepting a pointer, instead. The definition of getline above is compiled 
exactly as if it had been written
 
	int getline(char *line, int max)
	{
	...
	}e allora perch� usare la forma di array?Per leggibilit�? 
 
 

         }e allora perchè usare la forma di array?Per leggibilità?
 
Confesso di aver capito poco della tua domanda e
autorisposta seguente.
In generale solo i parametri scalari int, char, float, ecc.
e i puntatori vengono passati nello stack. Ma ci sono
eccezioni, vedi i compilatori per i PIC senza un vero
stack.
Poi sta ai gusti del programmatore se passare line[]
o *line. La possibilita' di fare la stessa cosa scrivendola
in modo diversi e' uno dei vantaggi del C ma anche
un suo limite. Vedi le gare di chi scrive il programma
piu' incomprensibile.
http://en.wikipedia.org/wiki/International_Obfuscated_C_Code_Contest
 

 immagino la prima
 
Rispondo non tanto alla domanda quanto all'implementazione che stai facendo: 
tipicamente per calcolare il CRC si usa qualche funzione per inizializzare 
la routine, calcolare, estrarre il dato. Questo perchè non conosci a priori 
la lunghezza del pacchetto. Oggi mi sento buono e incollo un implementazione 
del CRC16 (quello del modbus).
 
In questa mini libreria si usa:
- InitCrc()  per inizializzare il CRC
- void CalcCrc(unsigned char ucdata)      per passare i byte
- GetCrcByte(unsigned char* ucCrcHi, unsigned char* ucCrcLow)   per estrarre 
byte per byte
- GetCrcWord(unsigned int* uiCrc)   per estrarre il crc16 per intero
 
Le tabelle servono per sprecare un po' di ROM a favore della velocità di 
esecuzione del codice!
 
Ciao
CG
 
--------------------------------------------------
 
 
#ifndef CRC16_C
#define CRC16_C
 
// ------------------------------------------------------------------------------------------
// ------------------------           Gestione 
    -----------------------------------
// ------------------------------------------------------------------------------------------
 
/* Table of CRC values for high-order byte */
const char _CRCHi[]  = {
   0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 
0x00, 0xC1, 0x81,
   0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 
0x40, 0x01, 0xC0,
   0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 
0x81, 0x40, 0x01,
   0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 
0xC0, 0x80, 0x41,
   0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
0x00, 0xC1, 0x81,
   0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 
0x41, 0x01, 0xC0,
   0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
0x80, 0x41, 0x01,
   0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 
0xC1, 0x81, 0x40,
   0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 
0x00, 0xC1, 0x81,
   0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 
0x40, 0x01, 0xC0,
   0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 
0x81, 0x40, 0x01,
   0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 
0xC0, 0x80, 0x41,
   0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
0x00, 0xC1, 0x81,
   0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 
0x40, 0x01, 0xC0,
   0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
0x80, 0x41, 0x01,
   0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 
0xC0, 0x80, 0x41,
   0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 
0x00, 0xC1, 0x81,
   0x40
};
 
/* Table of CRC values for low-order byte */
const char _CRCLo[] = {
   0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 
0x05, 0xC5, 0xC4,
   0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 
0x0B, 0xC9, 0x09,
   0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 
0xDF, 0x1F, 0xDD,
   0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 
0x12, 0x13, 0xD3,
   0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 
0x36, 0xF6, 0xF7,
   0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 
0xFE, 0xFA, 0x3A,
   0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 
0x2A, 0xEA, 0xEE,
   0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 
0xE7, 0xE6, 0x26,
   0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 
0x63, 0xA3, 0xA2,
   0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 
0x6D, 0xAF, 0x6F,
   0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 
0xB9, 0x79, 0xBB,
   0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 
0x74, 0x75, 0xB5,
   0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 
0x50, 0x90, 0x91,
   0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 
0x54, 0x9C, 0x5C,
   0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 
0x58, 0x98, 0x88,
   0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 
0x4D, 0x4C, 0x8C,
   0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 
0x41, 0x81, 0x80,
   0x40
};
 
 
union {
    unsigned char b[2];
    unsigned int d;
} __serial_crc;
 
 
void InitCrc() {
          __serial_crc.d = 0xFFFF;
}
 
 
// Purpose:    Calculate crc of data and updates global crc
// Inputs:     Character
// Outputs:    None
void CalcCrc(unsigned char ucdata) {
    unsigned char uIndex ; // will index into CRC lookup table
 
    uIndex = __serial_crc.b[1] ^ ucdata; // calculate the CRC
    __serial_crc.b[1] = __serial_crc.b[0] ^ _CRCHi[uIndex];
    __serial_crc.b[0] = _CRCLo[uIndex];
 
}
 
void GetCrcByte(unsigned char* ucCrcHi, unsigned char* ucCrcLow)  {
          *ucCrcHi = __serial_crc.b[1];
          *ucCrcLow = __serial_crc.b[0];
}
 
void GetCrcWord(unsigned int* uiCrc) {
          *uiCrc = __serial_crc.d;
}
 
 
#endif
 
 
 
 


vi e ti ringrazio e tengo buono
per adesso il mio CRC sta funzionando in modo algoritmico.
Se verso la fine del "lavoro" mi avanzer� tanta flash lo far� tabellare e un 
p� di codice gi� fatto mi far� comodo.
 
 
No,la domanda meglio scritta �  : perch� ,non potendo passare come parametro 
un array di lunghezza indefinita(credo),  in molti esempi si usa comunque 
questa forma, anzich� mostrare che si passa un puntatore? 
 
 

 comunque questa forma, anzich� mostrare che si passa un puntatore?
 
Probabilmente perch� il codice � pi� autoesplicativo....
 
Ciao
CG 
 
 

 questa forma, anzichè mostrare che si passa un puntatore?
 
 
Che io sappia l'unica differenza tra le due versioni è che il nome 
dell'array non supporta le operazioni proprie dei puntatori (es. array++ 
non è valido). Per il resto dovrebbero essere equivalenti.
 
Io personalmente utilizzo la notazione di tipo array per far capire 
appunto che si tratta di un array. Ma tecnicamente potresti utilizzare 
la notazione con puntatore senza problemi.
 
Marco