Wie functionieren designated initializers?

[Christian J. (Gast)]

Hallo,

kann mir jemand sagen wie das da unten funktioniert bzw. was das genau 
ist und wozu man es benutzen kann? Was ein struct ist, ist mir klar aber 
bei mir sehen die irgendwie einfacher aus.

static const struct pios_overo_cfg pios_overo_cfg = {
    .regs  = SPI2,
    .remap = GPIO_AF_SPI2,
    .init  = {
        .SPI_Mode              = SPI_Mode_Slave,
        .SPI_Direction         = SPI_Direction_2Lines_FullDuplex,
        .SPI_DataSize          = SPI_DataSize_8b,
        .SPI_NSS                                   = SPI_NSS_Hard,
        .SPI_FirstBit          = SPI_FirstBit_MSB,
        .SPI_CRCPolynomial     = 7,
        .SPI_CPOL              = SPI_CPOL_High,
        .SPI_CPHA              = SPI_CPHA_2Edge,
        .SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2,
    },
    .use_crc = false,
    .dma     = {
        .irq                                       = {
            // Note this is the stream ID that triggers interrupts (in this case TX)
            .flags = (DMA_IT_TCIF7),
            .init  = {
                .NVIC_IRQChannel    = DMA1_Stream7_IRQn,
                .NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH,
                .NVIC_IRQChannelSubPriority        = 0,
                .NVIC_IRQChannelCmd = ENABLE,
            },
        },

        .rx                                        = {
            .channel = DMA1_Stream0,
            .init    = {
                .DMA_Channel            = DMA_Channel_0,
                .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR),
                .DMA_DIR                = DMA_DIR_PeripheralToMemory,
                .DMA_PeripheralInc      = DMA_PeripheralInc_Disable,
                .DMA_MemoryInc          = DMA_MemoryInc_Enable,
                .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
                .DMA_MemoryDataSize     = DMA_MemoryDataSize_Byte,
                .DMA_Mode               = DMA_Mode_Circular,
                .DMA_Priority           = DMA_Priority_Medium,
                // TODO: Enable FIFO
                .DMA_FIFOMode           = DMA_FIFOMode_Disable,
                .DMA_FIFOThreshold      = DMA_FIFOThreshold_Full,
                .DMA_MemoryBurst        = DMA_MemoryBurst_Single,
                .DMA_PeripheralBurst    = DMA_PeripheralBurst_Single,
            },
        },
        .tx                                        = {
            .channel = DMA1_Stream7,
            .init    = {
                .DMA_Channel            = DMA_Channel_0,
                .DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR),
                .DMA_DIR                = DMA_DIR_MemoryToPeripheral,
                .DMA_PeripheralInc      = DMA_PeripheralInc_Disable,
                .DMA_MemoryInc          = DMA_MemoryInc_Enable,
                .DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte,
                .DMA_MemoryDataSize     = DMA_MemoryDataSize_Byte,
                .DMA_Mode               = DMA_Mode_Circular,
                .DMA_Priority           = DMA_Priority_Medium,
                .DMA_FIFOMode           = DMA_FIFOMode_Disable,
                .DMA_FIFOThreshold      = DMA_FIFOThreshold_Full,
                .DMA_MemoryBurst        = DMA_MemoryBurst_Single,
                .DMA_PeripheralBurst    = DMA_PeripheralBurst_Single,
            },
        },
    },
    .sclk                                          = {
        .gpio = GPIOB,
        .init = {
            .GPIO_Pin   = GPIO_Pin_13,
            .GPIO_Speed = GPIO_Speed_100MHz,
            .GPIO_Mode  = GPIO_Mode_AF,
            .GPIO_OType = GPIO_OType_PP,
            .GPIO_PuPd  = GPIO_PuPd_NOPULL
        },
    },
    .miso                                          = {
        .gpio = GPIOB,
        .init = {
            .GPIO_Pin   = GPIO_Pin_14,
            .GPIO_Speed = GPIO_Speed_50MHz,
            .GPIO_Mode  = GPIO_Mode_AF,
            .GPIO_OType = GPIO_OType_PP,
            .GPIO_PuPd  = GPIO_PuPd_NOPULL
        },
    },
    .mosi                                          = {
        .gpio = GPIOB,
        .init = {
            .GPIO_Pin   = GPIO_Pin_15,
            .GPIO_Speed = GPIO_Speed_50MHz,
            .GPIO_Mode  = GPIO_Mode_AF,
            .GPIO_OType = GPIO_OType_PP,
            .GPIO_PuPd  = GPIO_PuPd_NOPULL
        },
    },
    .slave_count                                   = 1,
    .ssel                                          = {
        {
            .gpio = GPIOB,
            .init = {
                .GPIO_Pin   = GPIO_Pin_12,
                .GPIO_Speed = GPIO_Speed_50MHz,
                .GPIO_Mode  = GPIO_Mode_OUT,
                .GPIO_OType = GPIO_OType_PP,
                .GPIO_PuPd  = GPIO_PuPd_UP
            },
        }
    },
};

[Clemens L. (c_l)]

Das sind einfach mehrfach verschachtelte Strukturen.

Die selbe Initialisierung würde als Code so aussehen:

pios_overo_cfg.regs  = SPI2;
pios_overo_cfg.remap = GPIO_AF_SPI2;
pios_overo_cfg.init.SPI_Mode              = SPI_Mode_Slave;
pios_overo_cfg.init.SPI_Direction         = SPI_Direction_2Lines_FullDuplex;
pios_overo_cfg.init.SPI_DataSize          = SPI_DataSize_8b;
//...
pios_overo_cfg.use_crc = false;
// Note this is the stream ID that triggers interrupts (in this case TX)
pios_overo_cfg.dma.irq.flags = (DMA_IT_TCIF7);
pios_overo_cfg.dma.irq.init.NVIC_IRQChannel    = DMA1_Stream7_IRQn;
pios_overo_cfg.dma.irq.init.NVIC_IRQChannelPreemptionPriority = PIOS_IRQ_PRIO_HIGH;
pios_overo_cfg.dma.irq.init.NVIC_IRQChannelSubPriority        = 0;
pios_overo_cfg.dma.irq.init.NVIC_IRQChannelCmd = ENABLE;
pios_overo_cfg.dma.rx.channel = DMA1_Stream0;
pios_overo_cfg.dma.rx.init.DMA_Channel            = DMA_Channel_0;
pios_overo_cfg.dma.rx.init.DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR);
//...

[Rufus Τ. F. (rufus)]

Vereinfacht:

struct bla
{
  int a;
  int b;
  int c;
};

// klassische Initialisierung

struct bla eins = { 1, 2, 3 };

// mit "designated initializers"

struct bla zwei = { .b = 2, .a = 1, .c = 3 };

Bei der klassischen Initialisierung müssen die Initialisierer in der 
korrekten Reihenfolge angegeben werden, wenn nur ein Element der 
Struktur (mit einem von 0 abweichenden Wert) initialisiert werden soll, 
dann müssen alle Elemente der Struktur, die in der Deklaration vorher 
stehen, auch initialisiert werden.

Will man im obigen Beispiel nur das Strukturelement c initialisieren, 
müssen der Reihenfolge wegen zwangsweise auch a und b initialisiert 
werden.

Bei "designated initializers" ist die Reihenfolge egal, und so ist auch 
eine alleinige Initialisierung von c möglich; a und b werden dann mit 0 
initialisiert.

[Rolf Magnus (Gast)]

Und gerade bei einer so komplexen Struktur hat man den Vorteil, dass man 
gleich sieht, welches Element welchen Wert bekommt, ohne dass man 
daneben noch die Definition des Typs sehen und die Elemente einzeln 
abzählen muss.

[Christian J. (Gast)]

Aha .... na, bisher bin ich irgendwie auch ohne das ausgekommen. 
Vermutlich weil ich so gut wie nie initialisierte Variablen brauche.