Как инициализировать все элементы в массиве до того же числа в С++

Ответ 1

Я удивлен всеми ответами, предлагающими vector. Это не то же самое!

Используйте std::fill, от <algorithm>:

int directory[100];
std::fill(directory, directory + 100, -1);

Не касается вопроса напрямую, но вам может понадобиться хорошая вспомогательная функция, когда дело доходит до массивов:

template <typename T, size_t N>
T* end(T (&pX)[N])
{
    return pX + N;
}

Дарение:

int directory[100];
std::fill(directory, end(directory), -1);

Поэтому вам не нужно дважды указывать размер.

Ответ 2

Я бы предложил использовать std::array. По трем причинам:
 1. массив обеспечивает безопасность выполнения во время индексирования вне диапазона в операциях подписи (т.е. operator[]),
 2. массив автоматически переносит размер без необходимости передавать его отдельно

 3. И самое главное, массив предоставляет метод fill(), который требуется для   эта проблема

#include <array>
#include <assert.h>

typedef std::array< int, 100 > DirectoryArray;

void test_fill( DirectoryArray const & x, int expected_value ) {
    for( size_t i = 0; i < x.size(); ++i ) {
        assert( x[ i ] == expected_value );
    }
}

int main() {
    DirectoryArray directory;
    directory.fill( -1 );
    test_fill( directory, -1 );
    return 0;
}

Использование массива требует использования "-std = С++ 0x" для компиляции (применимо к вышеуказанному коду).

Если это не доступно или если это не вариант, то другие параметры, такие как std:: fill() (как предложено GMan) или может быть выбрано ручное кодирование метода fill().

Ответ 3

Если вам действительно нужны массивы, вы можете использовать boosts array класс. Он присваивает члену работу:

boost::array<int,N> array; // boost arrays are of fixed size!
array.assign(-1);

Ответ 4

Если у вас было меньшее количество элементов, вы могли бы указать их один за другим. Инициализация массива работает, указывая каждый элемент, а не указывая одно значение, которое применяется для каждого элемента.

int x[3] = {-1, -1, -1 };

Вы также можете использовать вектор и использовать конструктор для инициализации всех значений. Позднее вы можете получить доступ к буферу необработанного массива, указав &v.front()

std::vector directory(100, -1);

Существует C способ сделать это, используя также memset или различные другие подобные функции. memset работает для каждого char в вашем указанном буфере, хотя он будет отлично работать для таких значений, как 0, но может не работать в зависимости от того, как хранятся отрицательные числа для -1.

Вы также можете использовать STL для инициализации массива с помощью fill_n. Для действия общего назначения для каждого элемента вы можете использовать for_each.

fill_n(directory, 100, -1);

Или, если вы действительно хотите, чтобы вы могли идти хромым способом, вы можете сделать цикл for с 100 итерациями и сделать directory[i] = -1;

Ответ 5

Он работает правильно. Ваше ожидание инициализатора неверно. Если вы действительно хотите воспользоваться этим подходом, вам понадобится 100 разделенных запятыми -1s в инициализаторе. Но что происходит, когда вы увеличиваете размер массива?

Ответ 6

Он работает правильно. Это то, как работают инициализаторы списков.

Я считаю, что 6.7.8.10 стандарта C99 охватывает это:

Если объект, который имеет автоматический длительность хранения не инициализируется явно, его значение неопределенный. Если объект, который имеет статическая продолжительность хранения не является инициализируется явно, тогда:

• если он имеет тип указателя, он инициализируется нулевым указателем;
• если он имеет арифметический тип, он инициализируется (положительным или без знака) нуль;
• если он является агрегатом, каждый член инициализируется (рекурсивно) в соответствии с к этим правилам;
• если это объединение, первый именованный элемент инициализируется (рекурсивно) согласно этим правилам.

Если вам нужно сделать все элементы в массиве одинаковыми ненулевыми значениями, вам придется использовать цикл или memset.

Также обратите внимание, что, если вы действительно не знаете, что делаете, векторы предпочтительнее массивов в С++:

Здесь вам нужно понять о контейнерах против массивов:

• Контейнерные классы делают программистов более продуктивными. Поэтому, если вы настаиваете на использовании массивов, в то время как те, кто захотят использовать классы контейнеров, вы, вероятно, будете менее продуктивными, чем они есть (даже если вы умнее и опытнее, чем они есть!).
• Контейнерные классы позволяют программистам писать более надежный код. Поэтому, если вы настаиваете на использовании массивов, в то время как те, кто захотят использовать классы контейнеров, у вашего кода, вероятно, будет больше ошибок, чем их код (даже если вы умнее и опытнее).
• И если вы настолько умны и настолько опытны, что можете использовать массивы так же быстро и безопасно, как они могут использовать классы контейнеров, кто-то еще, вероятно, в конечном итоге будет поддерживать ваш код, и они, вероятно, будут вводить ошибки. Или, что еще хуже, вы будете единственным, кто сможет поддерживать ваш код, поэтому руководство выдержит вас от разработки и перенесет вас на полноценную службу поддержки - именно то, что вы всегда хотели!

В связанном вопросе гораздо больше; дайте ему прочитать.

Ответ 7

используйте вектор int вместо массива.

vector<int> directory(100,-1);                       // 100 ints with value 1

Ответ 8

u просто используйте для цикла, как показано ниже: -

for (int i=0; i<100; i++)
{ 
a[i]= -1;
}

в результате, так как вы хотите, чтобы u мог получить A [100] = {- 1, -1, -1.......... (100 раз)}

Ответ 9

Невозможно выполнить то, что вы пытаетесь сделать с необработанным массивом (если вы явно не перечисляете все 100 -1 в списке инициализаторов), вы можете сделать это с помощью vector:

vector<int> directory(100, -1);

Кроме того, вы можете создать массив и установить значения -1, используя один из других упомянутых методов.

Ответ 10

Просто используйте этот цикл.

for(int i =0 ; i < 100 ; i++) directory[i] =0;

Ответ 11

almighty memset() выполнит задание для контейнеров array и std в C/С++/С++ 11/С++ 14

Ответ 12

Причина, по которой int directory[100] = {-1} не работает, связана с тем, что происходит с инициализацией массива.

Все элементы массива, которые не инициализируются явно, инициализируются неявно так же, как объекты, имеющие статическую продолжительность хранения.

int, которые неявно инициализированы:

инициализируется беззнаковым нулем

Все элементы массива, которые не инициализируются явно, инициализируются неявно так же, как объекты, имеющие статическую продолжительность хранения.

С++ 11 представил begin и end, которые специализированы для массивов!

Это означает, что для данного массива (а не только для указателя), такого как directory, вы можете использовать fill, как было предложено в нескольких ответах:

fill(begin(directory), end(directory), -1)

Скажем, что вы пишете такой код, но затем решите повторно использовать функциональные возможности, забыв, как вы его реализовали, но вы решили изменить размер directory на 60. Если вы написали код с помощью begin и end, тогда вы закончите.
Если, с другой стороны, вы сделали это: fill(directory, directory + 100, -1), тогда вам лучше помнить об изменении этого значения от 100 до 60, или вы получите поведение undefined.

Ответ 13

У меня был тот же вопрос, и я нашел, как это сделать, в документации приведен следующий пример:

std::array<int, 3> a1{ {1, 2, 3} }; // double-braces required in C++11 (not in C++14)

Итак, я просто попробовал:

std::array<int, 3> a1{ {1} }; // double-braces required in C++11 (not in C++14)

И он работает, все элементы имеют значение 1. Он не работает с оператором =. Возможно, это проблема С++ 11.

Ответ 14

Если вам разрешено использовать std:: array, вы можете сделать следующее:

#include <iostream>
#include <algorithm>
#include <array>
using namespace std;

template <class Elem, Elem pattern, size_t S, size_t L>
struct S_internal {
    template <Elem... values>
    static array<Elem, S> init_array() {
        return S_internal<Elem, pattern, S, L - 1>::init_array<values..., pattern>();
    }
};

template <class Elem, Elem pattern, size_t S>
struct S_internal<Elem, pattern, S, 0> {
    template <Elem... values>
    static array<Elem, S> init_array() {
        static_assert(S == sizeof...(values), "");
        return array<Elem, S> {{values...}};
    }
};

template <class Elem, Elem pattern, size_t S>
struct init_array
{
    static array<Elem, S> get() {
        return S_internal<Elem, pattern, S, S>::init_array<>();
    }
};

void main()
{
    array<int, 5> ss = init_array<int, 77, 5>::get();
    copy(cbegin(ss), cend(ss), ostream_iterator<int>(cout, " "));
}

Вывод:

77 77 77 77 77