c++ - una - matriz de caracteres en c

Cómo inicializar todos los elementos en una matriz al mismo número en C++

Question

Estoy tratando de inicializar una matriz int con todo configurado en -1.

Intenté lo siguiente, pero no funciona. Solo establece el primer valor en -1.

int directory[100] = {-1};

¿Por qué no funciona bien?

Answer 1

Está funcionando bien. Así es como funcionan los inicializadores de lista.

Creo que 6.7.8.10 de la norma C99 cubre esto:

Si un objeto que tiene una duración de almacenamiento automático no se inicializa explícitamente, su valor es indeterminado. Si un objeto que tiene una duración de almacenamiento estático no se inicializa explícitamente, entonces:

• si tiene un tipo de puntero, se inicializa a un puntero nulo;
• si tiene tipo aritmético, se inicializa a (positivo o sin signo) cero;
• si es un agregado, cada miembro se inicializa (recursivamente) de acuerdo con estas reglas;
• si es una unión, el primer miembro nombrado se inicializa (recursivamente) de acuerdo con estas reglas.

Si necesita hacer que todos los elementos de una matriz tengan el mismo valor distinto de cero, deberá utilizar un bucle o memset .

También tenga en cuenta que, a menos que realmente sepa lo que está haciendo, los vectores son preferibles a los arreglos en C ++ :

Esto es lo que necesita saber acerca de los contenedores frente a las matrices:

1. Las clases de contenedores hacen que los programadores sean más productivos. Por lo tanto, si insiste en utilizar matrices mientras que los que lo rodean están dispuestos a usar clases en contenedor, probablemente será menos productivo que ellos (¡incluso si es más inteligente y más experimentado que ellos!).
2. Las clases de contenedor permiten a los programadores escribir código más robusto. Por lo tanto, si insiste en utilizar matrices mientras que los que lo rodean están dispuestos a usar clases en contenedor, su código probablemente tendrá más errores que su código (incluso si es más inteligente y tiene más experiencia).
3. Y si eres tan inteligente y tan experimentado que puedes usar arreglos tan rápido y tan seguro como ellos pueden usar clases en contenedor, alguien más terminará manteniendo tu código y probablemente introducirá errores. O peor, serás el único que puede mantener tu código, por lo que la administración te sacará del desarrollo y te llevará a un rol de mantenimiento a tiempo completo, ¡justo lo que siempre quisiste!

Hay mucho más en la pregunta vinculada; dale una lectura

Answer 2

Estoy sorprendido por todas las respuestas que sugieren vector . ¡Ni siquiera son lo mismo!

Use std::fill , desde <algorithm> :

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

No le preocupa la pregunta directamente, pero es posible que desee una buena función de ayuda cuando se trata de matrices:

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

Dando

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

Así que no necesitas listar el tamaño dos veces.

Answer 3

Funciona bien. Su expectativa del inicializador es incorrecta. Si realmente desea adoptar este enfoque, necesitará 100 -1s separados por comas en el inicializador. Pero entonces, ¿qué sucede cuando aumentas el tamaño de la matriz?

Answer 4

La razón por la que el int directory[100] = {-1} no funciona es debido a lo que sucede con la inicialización de la matriz .

Todos los elementos de la matriz que no se inicializan explícitamente se inicializan implícitamente de la misma manera que los objetos que tienen una duración de almacenamiento estático.

int s que están inicializados implícitamente son:

inicializado a cero sin firmar

Todos los elementos de la matriz que no se inicializan explícitamente se inicializan implícitamente de la misma manera que los objetos que tienen una duración de almacenamiento estático.

C ++ 11 introdujo el begin y el end que están especializados para arreglos!

Esto significa que dada una matriz (no solo un puntero), como su directory , puede usar el std::fill como se ha sugerido en varias respuestas:

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

Supongamos que escribe un código como este, pero luego decide reutilizar la funcionalidad después de haber olvidado cómo lo implementó, pero decidió cambiar el tamaño del directory a 60. Si escribió un código utilizando el begin y el end entonces está hecho.
Si, por otro lado, has hecho esto: fill(directory, directory + 100, -1) entonces es mejor que recuerdes cambiar ese 100 a un 60 también, o obtendrás un comportamiento indefinido.

Answer 5

No puede hacer lo que está tratando de hacer con una matriz en bruto (a menos que enumere explícitamente todos los 100 -1 s en la lista de inicializadores), puede hacerlo con un vector :

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

Además, puede crear la matriz y establecer los valores en -1 utilizando uno de los otros métodos mencionados.

Answer 6

Sólo tiene que utilizar este bucle.

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

Answer 7

Si realmente necesita arreglos, puede usar la clase de array . Es el miembro asignado hace el trabajo:

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

Answer 8

Si tiene permiso para usar std :: array, puede hacer lo siguiente:

#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, " "));
}

La salida es:

77 77 77 77 77

Answer 9

Si tuviera un número menor de elementos, podría especificarlos uno tras otro. La inicialización de la matriz funciona especificando cada elemento, no especificando un solo valor que se aplique a cada elemento.

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

También puede usar un vector y el constructor para inicializar todos los valores. Más tarde, puede acceder al búfer de matriz sin &v.front() especificando &v.front()

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

Hay una forma en C de hacerlo también utilizando memset u otras funciones similares. memset funciona para cada char en su búfer especificado, así que funcionará bien para valores como 0 pero puede no funcionar dependiendo de cómo se almacenan los números negativos para -1 .

También puede usar STL para inicializar su matriz usando fill_n . Para una acción de propósito general para cada elemento que podrías usar para for_each.

fill_n(directory, 100, -1);

O, si realmente quieres, puedes ir por el camino cojo, puedes hacer un bucle for con 100 iteraciones y haciendo el directory[i] = -1;

Answer 10

Sugeriría usar std::array . Por tres razones:
1. la matriz proporciona seguridad de tiempo de ejecución contra el índice fuera de límite en las operaciones de creación de subíndices (es decir, operator[] ),
2. la matriz lleva automáticamente el tamaño sin necesidad de pasarlo por separado
3. Y lo más importante, array proporciona el método fill() que se requiere para este problema

#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;
}

El uso de la matriz requiere el uso de "-std = c ++ 0x" para compilar (se aplica al código anterior).

Si eso no está disponible o si no es una opción, entonces se pueden optar las otras opciones como std :: fill () (según lo sugiere GMan ) o la codificación manual del método a fill ().

Answer 11

Tuve la misma pregunta y encontré cómo hacerlo, la documentación da el siguiente ejemplo:

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

Así que lo intenté:

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

Y funciona todos los elementos tienen 1 como valor. No funciona con el operador =. Es tal vez un problema de C ++ 11.

Answer 12

U simplemente utiliza para bucle como se hace a continuación:

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

como resultado, como quieras, puedes obtener A [100] = {- 1, -1, -1 .......... (100 veces)}

Answer 13

el todopoderoso memset () hará el trabajo para los contenedores array y std en C / C ++ / C ++ 11 / C ++ 14

Answer 14

usa vector de int en lugar de un array.

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