C, skapa 10 bitars array?

Jag antar att du vill skapa en array an en godtycklig storlek som innehåller 10-bitars bitfält. Om du först skapar ditt bitfält som du beskriver ovan med

struct bitfield {
    unsigned int number:10;
};

så kan du sedan skapa en array som innehåller tio sådana;

struct bitfield bf10[10];

Eller definiera och skapa arrayen på en gång:

struct bitfield {
    unsigned int number:10;
} bf10[10];

Om du istället ville ha en array med 10 bitar där du enkelt kan sätta varje bit för sig skapar du istället ett bitfält med 10st individuella fält som är 1 bit breda, dvs:

struct bitfield {
    unsigned int bit0 : 1;
    unsigned int bit1 : 1;
    ....
    unsigned int bit9 : 1;
} bf10;

bf10.bit0 = 0;
bf10.bit1 = 1;
....

Är det inte enklare att bara använda de 10 lägsta bitarna i en uint16_t istället?

Hur mycket utrymme en struct med diverse element i tar upp beror på arkitektur, kompilator och kompilatorflaggor. Oftast sätts padding in i structen så att varje medlem alignar till arkitekturerns word-size, men det går att komma runt (i de flesta fall) genom att tala om för kompilatorn att man inte vill aligna medlemmarna i structen. Om minnesutrymmet är väldigt viktigt kan du kolla upp i din kompilatormanual om det finns möjlighet att stänga av padding.

En int är inte definierad till 32 bitar, en short är inte definierad till 16 bitar och en char är inte definierad till 8 bitar. Det beror helt och hållet på vilket system du kompilerar för. Använd typdefinitionerna från <stdint.h> om du behöver en datatyp av en viss storlek.

Storleken på en int är inte exakt fastställd i C-standarden, så den kan variera beroende på kompilator, arkitektur m.m. Det går inte att lita på att den alltid är exakt 32 bitar stor.

Bitfält bör inte användas över huvud taget, eftersom det inte finns någon fastställd standard för hur padding, endianness osv hanteras. Ska man skicka över nätverket finns det standardiserade funktioner (hton() m.fl. har jag för mig att dom heter) som konverterar data till ett standardiserat format för nätverkstrafik.

void main() {
	struct bitfield {
		unsigned int number:10;
	} bf10[10];
	printf("%d", sizeof(bf10) * 8);
}

Vad använder du för kompilator? Kolla upp om det finns några kompilatorflaggor eller andra tricks i koden för att tvinga den att inte padda/aligna structmedlemmar.

Jag kanske inte varit helt tydlig i det jag skrivit, men den totala storleken på en struct kan ju aldrig bli mindre än en heltalsmultipel av 8 eftersom man inte kan adressera mindre än 1 byte (det finns såklart undantag, men normalt sett). Men med hjälp av t.ex. __attribute(packed) i GCC kan man göra sina structar så små som möjligt inom gränserna för vad som är tillåtet.

Vilken kommentar menar du är överflödig?

Som nämnts tidigare kan du inte skapa arrayer vars element är av godtycklig storlek. Oavsett hur det paddas fram och tillbaka så måste elementen alignas till vad som är adresserbart. Du kan däremot, om du är riktigt desperat, skapa en array av bytes som så nära som möjligt täcker det utrymmet du ville allokera, och därefter skriva egna funktioner för read/write. Då kan du tex allokera dina 10*10 bitar med 13 bytes, och för att få ut tex andra elementet som såklart är o-adresserbart, så behöver du bara plocka ut andra och tredje byten (adresserbara) och shifta bitar lite höger och vänster. Om du är riktigt desperat som sagt.

Aha, nu förstår jag. Det går ju som du sa tidigare inte att få den att bli exakt 100 bitar eftersom bitfältet på 10-bitar i fallet man har det som en unsigned int kommer att paddas upp till 32 bitar. Men om man använder __attribute(packed) så kommer GCC att minimera det onödiga utrymmet, och lagra de tio bitarna i bitfältet i 2 st byte-stora variabler.

struct bitfield_packed {
    unsigned int number:10;
} __attribute__((packed));

struct bitfield_packed bf10[10];

printf("%lu\n", sizeof(bf10) * 8);

Utskriften från det blir 160, kompilerat för ett x86_64-bitars system med gcc.

Det borde det vara, så länge vi pratar "normala" arkitekturer och "normala" kompilatorer Förutsatt att varje element måste vara just 10 bitar, annars kan man ju strukturera ihop dom lite annorlunda och komma ner i utrymme. Men om man inte jobbar med extremt resursbegränsade inbyggda system så borde inte minnesutrymmet spela någon som helst roll i det här fallet Några byte är ju ganska så billigt nu för tiden.