Inicialização de todos os elementos de uma matriz para um valor padrão em C ++?

Notas sobre C ++: A inicialização de matrizes possui uma boa lista sobre a inicialização de matrizes. eu tenho um

int array[100] = {-1};

esperando que esteja cheio de -1, mas não, apenas o primeiro valor é e o restante é 0 misturado com valores aleatórios.

O código

int array[100] = {0};

funciona bem e define cada elemento como 0.

O que estou perdendo aqui .. Não é possível inicializá-lo se o valor não for zero?

E 2: a inicialização padrão (como acima) é mais rápida que o loop usual em toda a matriz e atribui um valor ou faz a mesma coisa?

Usando a sintaxe que você usou,

int array[100] = {-1};

diz "defina o primeiro elemento como -1e o restante como 0", pois todos os elementos omitidos estão definidos como 0.

No C ++, para configurá-los todos -1, você pode usar algo como std::fill_n(de <algorithm>):

std::fill_n(array, 100, -1);

No C portátil, você precisa rolar seu próprio loop. Existem extensões do compilador ou você pode depender do comportamento definido pela implementação como um atalho, se isso for aceitável.

Há uma extensão para o compilador gcc que permite a sintaxe:

int array[100] = { [0 ... 99] = -1 };

Isso definiria todos os elementos para -1.

Isso é conhecido como "Inicializadores Designados", consulte aqui para obter mais informações.

Observe que isso não foi implementado para o compilador gcc c ++.

A página à qual você vinculou já deu a resposta para a primeira parte:

Se um tamanho explícito de matriz for especificado, mas uma lista de inicialização mais curta for especificada, os elementos não especificados serão definidos como zero.

Não há uma maneira interna de inicializar toda a matriz para um valor diferente de zero.

Quanto ao que é mais rápido, aplica-se a regra usual: "O método que dá ao compilador a maior liberdade provavelmente é mais rápido".

int array[100] = {0};

simplesmente diz ao compilador "defina essas 100 polegadas para zero", que o compilador pode otimizar livremente.

for (int i = 0; i < 100; ++i){
  array[i] = 0;
}

é muito mais específico. Diz ao compilador para criar uma variável de iteração i, informa a ordem em que os elementos devem ser inicializados e assim por diante. Obviamente, é provável que o compilador otimize isso, mas o ponto é que aqui você está superespecificando o problema, forçando o compilador a trabalhar mais para obter o mesmo resultado.

Finalmente, se você deseja definir a matriz para um valor diferente de zero, você deve (pelo menos em C ++) usar std::fill:

std::fill(array, array+100, 42); // sets every value in the array to 42

Novamente, você pode fazer o mesmo com uma matriz, mas isso é mais conciso e oferece mais liberdade ao compilador. Você está apenas dizendo que deseja que toda a matriz seja preenchida com o valor 42. Você não diz nada sobre a ordem em que deve ser feita ou qualquer outra coisa.

O C ++ 11 tem outra opção (imperfeita):

std::array<int, 100> a;
a.fill(-1);

Com {} você atribui os elementos como eles são declarados; o restante é inicializado com 0.

Se não houver = {}para inicializar, o conteúdo é indefinido.

A página que você vinculou

Se um tamanho explícito de matriz for especificado, mas uma lista de inicialização mais curta for especificada, os elementos não especificados serão definidos como zero.

Problema de velocidade: quaisquer diferenças seriam insignificantes para matrizes tão pequenas. Se você trabalha com matrizes grandes e a velocidade é muito mais importante que o tamanho, pode ter uma matriz const dos valores padrão (inicializados em tempo de compilação) e depois memcpypara a matriz modificável.

Outra maneira de inicializar a matriz com um valor comum seria realmente gerar a lista de elementos em uma série de define:

#define DUP1( X ) ( X )
#define DUP2( X ) DUP1( X ), ( X )
#define DUP3( X ) DUP2( X ), ( X )
#define DUP4( X ) DUP3( X ), ( X )
#define DUP5( X ) DUP4( X ), ( X )
.
.
#define DUP100( X ) DUP99( X ), ( X )

#define DUPx( X, N ) DUP##N( X )
#define DUP( X, N ) DUPx( X, N )

A inicialização de uma matriz para um valor comum pode ser feita facilmente:

#define LIST_MAX 6
static unsigned char List[ LIST_MAX ]= { DUP( 123, LIST_MAX ) };

Nota: DUPx introduzido para ativar a substituição de macro nos parâmetros do DUP

No caso de uma matriz de elementos de byte único, você pode usar o memset para definir todos os elementos com o mesmo valor.

Há um exemplo aqui .

Usando std::array, podemos fazer isso de uma maneira bastante direta no C ++ 14. É possível fazer apenas no C ++ 11, mas um pouco mais complicado.

Nossa interface é um tamanho em tempo de compilação e um valor padrão.

template<typename T>
constexpr auto make_array_n(std::integral_constant<std::size_t, 0>, T &&) {
    return std::array<std::decay_t<T>, 0>{};
}

template<std::size_t size, typename T>
constexpr auto make_array_n(std::integral_constant<std::size_t, size>, T && value) {
    return detail::make_array_n_impl<size>(std::forward<T>(value), std::make_index_sequence<size - 1>{});
}


template<std::size_t size, typename T>
constexpr auto make_array_n(T && value) {
    return make_array_n(std::integral_constant<std::size_t, size>{}, std::forward<T>(value));
}

A terceira função é principalmente por conveniência, de modo que o usuário não precisa construir a std::integral_constant<std::size_t, size>si próprio, pois essa é uma construção bastante prolífica. O trabalho real é realizado por uma das duas primeiras funções.

A primeira sobrecarga é bem direta: ela cria um std::arraytamanho 0. Não há cópia necessária, apenas a construímos.

A segunda sobrecarga é um pouco mais complicada. Ele encaminha o valor obtido como fonte e também constrói uma instância make_index_sequencee apenas chama alguma outra função de implementação. Como é essa função?

namespace detail {

template<std::size_t size, typename T, std::size_t... indexes>
constexpr auto make_array_n_impl(T && value, std::index_sequence<indexes...>) {
    // Use the comma operator to expand the variadic pack
    // Move the last element in if possible. Order of evaluation is well-defined
    // for aggregate initialization, so there is no risk of copy-after-move
    return std::array<std::decay_t<T>, size>{ (static_cast<void>(indexes), value)..., std::forward<T>(value) };
}

}   // namespace detail

Isso constrói os argumentos do primeiro tamanho - 1, copiando o valor que passamos. Aqui, usamos nossos índices variados do pacote de parâmetros como algo para expandir. Existem entradas size - 1 nesse pacote (conforme especificado na construção de make_index_sequence) e elas têm valores de 0, 1, 2, 3, ..., tamanho - 2. No entanto, não nos importamos com os valores ( então nós o lançamos para anular, para silenciar qualquer aviso do compilador). A expansão do pacote de parâmetros expande nosso código para algo assim (assumindo tamanho == 4):

return std::array<std::decay_t<T>, 4>{ (static_cast<void>(0), value), (static_cast<void>(1), value), (static_cast<void>(2), value), std::forward<T>(value) };

Usamos esses parênteses para garantir que a expansão variada do pacote ...expanda o que queremos e também para garantir que estamos usando o operador vírgula. Sem os parênteses, parece que estamos passando um monte de argumentos para a inicialização de nossa matriz, mas, na verdade, estamos avaliando o índice, lançando-o para nulo, ignorando esse resultado nulo e retornando o valor, que é copiado na matriz .

O argumento final, o que chamamos std::forward, é uma otimização menor. Se alguém passar uma std :: string temporária e disser "faça uma matriz de 5 delas", gostaríamos de ter 4 cópias e 1 movimentação, em vez de 5 cópias. O std::forwardgarante que fazemos isso.

O código completo, incluindo cabeçalhos e alguns testes de unidade:

#include <array>
#include <type_traits>
#include <utility>

namespace detail {

template<std::size_t size, typename T, std::size_t... indexes>
constexpr auto make_array_n_impl(T && value, std::index_sequence<indexes...>) {
    // Use the comma operator to expand the variadic pack
    // Move the last element in if possible. Order of evaluation is well-defined
    // for aggregate initialization, so there is no risk of copy-after-move
    return std::array<std::decay_t<T>, size>{ (static_cast<void>(indexes), value)..., std::forward<T>(value) };
}

}   // namespace detail

template<typename T>
constexpr auto make_array_n(std::integral_constant<std::size_t, 0>, T &&) {
    return std::array<std::decay_t<T>, 0>{};
}

template<std::size_t size, typename T>
constexpr auto make_array_n(std::integral_constant<std::size_t, size>, T && value) {
    return detail::make_array_n_impl<size>(std::forward<T>(value), std::make_index_sequence<size - 1>{});
}

template<std::size_t size, typename T>
constexpr auto make_array_n(T && value) {
    return make_array_n(std::integral_constant<std::size_t, size>{}, std::forward<T>(value));
}



struct non_copyable {
    constexpr non_copyable() = default;
    constexpr non_copyable(non_copyable const &) = delete;
    constexpr non_copyable(non_copyable &&) = default;
};

int main() {
    constexpr auto array_n = make_array_n<6>(5);
    static_assert(std::is_same<std::decay_t<decltype(array_n)>::value_type, int>::value, "Incorrect type from make_array_n.");
    static_assert(array_n.size() == 6, "Incorrect size from make_array_n.");
    static_assert(array_n[3] == 5, "Incorrect values from make_array_n.");

    constexpr auto array_non_copyable = make_array_n<1>(non_copyable{});
    static_assert(array_non_copyable.size() == 1, "Incorrect array size of 1 for move-only types.");

    constexpr auto array_empty = make_array_n<0>(2);
    static_assert(array_empty.empty(), "Incorrect array size for empty array.");

    constexpr auto array_non_copyable_empty = make_array_n<0>(non_copyable{});
    static_assert(array_non_copyable_empty.empty(), "Incorrect array size for empty array of move-only.");
}

1) Quando você usa um inicializador, para uma estrutura ou uma matriz como essa, os valores não especificados são essencialmente construídos por padrão. No caso de um tipo primitivo como ints, isso significa que eles serão zerados. Observe que isso se aplica recursivamente: você pode ter uma matriz de estruturas contendo matrizes e, se especificar apenas o primeiro campo da primeira estrutura, todo o resto será inicializado com zeros e construtores padrão.

2) O compilador provavelmente irá gerar um código inicializador que seja pelo menos tão bom quanto você poderia fazer manualmente. Costumo preferir deixar o compilador fazer a inicialização para mim, quando possível.

Em C ++, também é possível usar meta programação e modelos variados. A seguinte postagem mostra como fazer isso: Crie programaticamente matrizes estáticas em tempo de compilação em C ++ .

Na linguagem de programação C ++ V4, o Stroustrup recomenda o uso de vetores ou valarrays sobre matrizes internas. Com os valarrarys, quando você os cria, você pode iniciá-los com um valor específico, como:

valarray <int>seven7s=(7777777,7);

Para inicializar uma matriz com 7 membros, com "7777777".

Essa é uma maneira C ++ de implementar a resposta usando uma estrutura de dados C ++ em vez de uma matriz "C simples e antiga".

Eu mudei para usar o valarray como uma tentativa no meu código para tentar usar C ++ 'isms v. C'isms ....

Deve ser um recurso padrão, mas por algum motivo não está incluído no padrão C nem C ++ ...

#include <stdio.h>

 __asm__
 (
"    .global _arr;      "
"    .section .data;    "
"_arr: .fill 100, 1, 2; "
 );

extern char arr[];

int main() 
{
    int i;

    for(i = 0; i < 100; ++i) {
        printf("arr[%u] = %u.\n", i, arr[i]);
    }
}

No Fortran, você poderia fazer:

program main
    implicit none

    byte a(100)
    data a /100*2/
    integer i

    do i = 0, 100
        print *, a(i)
    end do
end

mas não possui números não assinados ...

Por que o C / C ++ não pode simplesmente implementá-lo. Isso é realmente tão difícil? É tão tolo ter que escrever isso manualmente para obter o mesmo resultado ...

#include <stdio.h>
#include <stdint.h>

/* did I count it correctly? I'm not quite sure. */
uint8_t arr = {
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
};    

int main() 
{
    int i;

    for(i = 0; i < 100; ++i) {
        printf("arr[%u] = %u.\n", i, arr[i]);
    }
}

E se fosse uma matriz de 1.000,00 bytes? Eu precisaria escrever um script para escrever para mim ou recorrer a hacks com assembly / etc. Isso não faz sentido.

É perfeitamente portátil, não há razão para não estar no idioma.

Basta invadir como:

#include <stdio.h>
#include <stdint.h>

/* a byte array of 100 twos declared at compile time. */
uint8_t twos[] = {100:2};

int main()
{
    uint_fast32_t i;
    for (i = 0; i < 100; ++i) {
        printf("twos[%u] = %u.\n", i, twos[i]);
    }

    return 0;
}

Uma maneira de invadir isso é através do pré-processamento ... (O código abaixo não cobre casos extremos, mas é escrito para demonstrar rapidamente o que poderia ser feito.)

#!/usr/bin/perl
use warnings;
use strict;

open my $inf, "<main.c";
open my $ouf, ">out.c";

my @lines = <$inf>;

foreach my $line (@lines) {
    if ($line =~ m/({(\d+):(\d+)})/) {
        printf ("$1, $2, $3");        
        my $lnew = "{" . "$3, "x($2 - 1) . $3 . "}";
        $line =~ s/{(\d+:\d+)}/$lnew/;
        printf $ouf $line;
    } else {
        printf $ouf $line;
    }
}

close($ouf);
close($inf);