initializng una matrice C con i dati ripetitivi

Question

vorrei inizializzare un array di struct, con lo stesso elemento ripetutamente, cioè

struct st ar[] = { {1,2}, {1,2}, {1,2} }; 

Comunque io non voglio correre alcun codice per questo, mi auguro che il il layout della memoria al momento dell'esecuzione del programma sarebbe come tale, senza le istruzioni della CPU coinvolte (aumenterebbe il tempo di avvio su CPU molto lente e array relativamente grandi).

Questo ha senso, quando si utilizza la matrice come mini banca dati ad hoc (mappe id a struct) e quando si desidera utilizzare un valore di default a tutti i valori di database.

La mia soluzione migliore era quella di usare qualcosa di forma

#define I {1,2} 
struct st ar[SIZE_OF_ARRAY] = { I,I,I }; 

modo che il compilatore mi avvisa se sto avendo troppo o troppo poco I s. Ma questo è lontano dall'ideale.

Penso che ci sia alcuna soluzione per questo in ANSI-C, ma ho pensato che forse c'è un macro-abusi, o estensione gcc che avrebbe fatto il lavoro. Idealmente mi piacerebbe una soluzione standard, ma basterebbero anche quelli specifici del compilatore.

Ho pensato che in qualche modo sarei stato in grado di definire una macro in modo ricorsivo in modo che I(27) sarebbe stato risolto in 27 {1,2} s, ma non credo sia possibile. Ma forse mi sbaglio, c'è qualche trucco per quello?

Forse l'assemblaggio in linea farebbe il trucco? Sarebbe molto facile definire tale layout di memoria con MASM o TASM, ma non sono sicuro che sia possibile incorporare le istruzioni di layout della memoria all'interno del codice C.

C'è qualche trucco linker che attirarlo per inizializzare la memoria secondo i miei ordini?

PS I know Posso generare automaticamente il file C con qualche script. L'uso di script personalizzati non è desiderabile. Se usassi uno script personalizzato, inventerei una macro C REP(count,exp,sep) e scriverei un preprocessore mini-C per sostituirlo con exp sep exp sep ... exp {exp appears count time}.

Answer 1

Il boost preprocessor library (che funziona bene per C) potrebbe aiutare.

#include <boost/preprocessor/repetition/enum.hpp> 

#define VALUE(z, n, text) {1,2} 

struct st ar[] = { 
    BOOST_PP_ENUM(27, VALUE, _) 
}; 

#undef VALUE 

Se si desidera utilizzarlo, ti basta la directory boost/preprocessor dalla spinta - è del tutto autonomo.

Sebbene abbia alcuni limiti arbitrari sul numero di elementi (penso che siano in questo caso 256 ripetizioni). Esiste un'alternativa denominata chaos che non lo è, ma è sperimentale e funzionerà solo per i preprocessori che seguono esattamente lo standard (GCC fa).

Answer 2

Quello che hai in forma di I s è il miglior standard C può dare. Non capisco come si possa essere contrari al codice di inizializzazione standard, ma va bene con il montaggio. L'assemblaggio di incorporamento è necessariamente un meccanismo non portatile non standard.

Il problema con le macro ricorsive è che non si saprebbe dove fermarsi.

Answer 3

Il modo più semplice che posso pensare è quello di scrivere uno script per generare gli inizializzatori che è possibile includere nel codice C:

{1,2}, 
{1,2}, 
{1,2} 

Poi, nel tuo fonte:

struct st ar[] = { 
    #include "init.inc" 
}; 

Puoi organizza il tuo Makefile per generare automaticamente se lo desideri.

Answer 4

ti sto indovinando posso, sul file con la definizione matrice, ne:

#include "rep_array_autogen.c" 
struct st ar[SIZE_OF_ARRAY] = REPARRAY_DATA; 

e avere il vostro Makefile generare rep_array_autogen.c con un formato simile

#define SIZE_OF_ARRAY 3 
#define REPARRAY_DATA {{1, 2}, {1, 2}, {1, 2}, } 

Dal rep_array_autogen.c è costruito su la tua macchina, sarebbe altrettanto veloce di codificarla a mano lì dentro.

Answer 5

Elazar,

Puoi dare i dati per sostenere il vostro parere che i dati pre-inizializzati è più veloce di run-time di inizializzazione?

Se si sta eseguendo il codice su una macchina standard con Hard Disk Drive (HDD) e il programma si trova sull'HDD, quindi il tempo necessario per copiare i dati dalla sezione di dati della propria immagine binaria alla RAM è essenzialmente la stessa quantità di tempo di utilizzo di alcuni tipi di inizializzazione di runtime.

Kip Leitner