existe alguna forma para que en un array todas las VARIABLES tengan el mismo valor inicial sin usar un bucle FOR o WHILE.
aqui un ejemplo de como lo he logrado con un bucle FOR.
#include<iostream>
using namespace std;
int main(){
int a[10];
for(int i = 0;i < 10;i++){
a[i] = 0;
}
}
la idea es que todas las VARIABLES que esten dentro del array a tengan el mismo valor.
NOTA:era un array, no una tabla (error de novato)
Por lo que entiendo, lo que llamas "tabla" (por qué las mayúsculas?), en C se llama un "array". Y los elementos de un array no son "variables", la variable es (en tu ejemplo) a , los elementos de un array se llaman... elementos de un array.
En general, no hay una manera más simple de escribir todos los elementos de un array con un mismo valor. El bucle for es la manera apropiada.
Digo "en general" porque en algunos casos particulares se puede hacer con memset: si se trata de un array de bytes (o chars), o si son int que inicializas a cero (como en tu caso). Es decir, en tu caso podrías reemplazar el bucle por
memset(&a[0], 0 , sizeof(int)*10);
pero esto rara vez es preferible al for- resulta más oscuro y difícil de mantener, y la ganancia es mínima.
Si no se trata de una asignación cualquiera, sino de la inicialización propiamente dicha (donde se declara la variable), hay una manera simple (siempre si se trata de inicializar a cero) :
int a[10] = { 0 };
Dependerá de qué valor inicial quieras asignar a los valores de dicha tabla y del tipo de los mismos.
Para el caso que expones en tu ejemplo:
int a[10];
Si quieres inicializar a valores 0 tienes las siguientes opciones:
int a[10] {};
El arreglo a recibe una lista vacía como valor inicial, esta lista vacía inicia todos sus elementos al valor por defecto del tipo del arreglo (int), en este caso el valor es 0... así que todos los elementos del arreglo a obtendrán el valor 0.
int a[10] = {};
El arreglo a copia los elementos de la lista facilitada como valor inicial, al estar esta lista vacía todos sus elementos contienen el valor por defecto del tipo del arreglo (int), en este caso el valor 0... así que todos los elementos del arreglo a obtendrán el valor 0.
Los compiladores actuales suelen optimizar esta inicialización de manera que se omite la copia en la mayoría de casos (realiza una inicialización del valor in situ siendo entonces equivalente a la inicialización por lista vacía); sin embargo no está garantizada la omisión de copia en otros tipos más complejos; siempre que tengas dudas de si una lista va a copiarse y quieres evitar dicha copia: usa la Inicialización por lista vacía.
static int a[10];
Los elementos estáticos son inicializados al valor por defecto incluso cuando no se les asigna un valor inicial, así que en el caso del arreglo estático a todos sus elementos contienen el valor por defecto del tipo del arreglo (int), en este caso el valor 0.
En el caso de querer inicializar a valores diferentes a 0, es más complicado:
int a[10] { 1 };
El arreglo a recibe una lista como valor inicial, esta lista contiene un único elemento de los 10 que acepta el arreglo... lo que sucederá es que el primer elemento del arreglo obtendrá el primer valor de la lista y el resto de elementos serán inicializados al valor por defecto del tipo del arreglo (int), que en este caso será 0, esto sucede hasta rellenar todos los valores del arreglo:
int b[10] { 1, 1 }; // los 8 ultimos elementos contienen 0
int c[10] { 1, 1, 1, 1 }; // los 6 ultimos elementos contienen 0
int d[10] { 1, 1, 1, 1, 1, 1, 1, 1, 1 }; // El ultimo elemento contiene 0
int a[10] = { 1 };
Sigue las mismas normas que la inicialización anterior pero copiando la lista facilitada (copia que generalmente es omitida por el compilador). Por lo tanto todos los elementos a los que no se les haya especificado valor, obtendrán el valor por defecto del tipo del arreglo (int), en este caso el valor 0.
Si quieres inicializar a un valor diferente al valor por defecto, deberás especificar el valor por cada uno de los elementos a inicializar; si esa es tu opción, puedes omitir el tamaño del arreglo y dejar que el compilador lo deduzca por ti:
int a[] {}; // Tamanyo 0!
int b[] { 1, 1 }; // Tamanyo 2
int c[] { 1, 1, 1, 1 }; // Tamanyo 4
int d[] { 1, 1, 1, 1, 1, 1, 1, 1, 1 }; // Tamanyo 9
Deberías echar un vistazo a los contenedores de la STL:
// Tabla de tamaño fijo
std::array<int,10> a; // Todos los valores inicializados a 0
// Tabla de tamaño variable
std::vector<int> b(10,2); // Todos los valores inicializados a 2
Y si no siempre puedes hacer uso de la inicialización por defecto (Solo sirve para arreglos de tamaño fijo):
int a[10] = { 0 };
Y si aun así las opciones anteriores no te sirven también puedes hacer uso de las funciones de la STL para inicializar el arreglo:
#include <algorithm>
int a[10];
// opción 1
std::fill(std::begin(a),std::end(a),0);
// opción 2
std::fill_n(a,10,0);
Un saludo
Si entiendo bien la pregunta, puedes usar la notación de inicialización en linea especificando los valores, que pueden ser iguales o diferentes, no importa.
int datos[3][3] = {
1,2,3,
4,5,6,
7,8,9
};
Como puedes ver, los valores se cargan de forma consecutiva, el identado es para facilitar la lectura.
Ten en cuenta que debes incluir la cantidad exacta de elementos declarados en la matriz (o sea 3 * 3 = 9).
Si es un vector con tamaño N, por defecto ya está inicializado con ceros.
vector <int> A(N);
Una manera de inicializar a todas con el mismo valor sería
int intArray[5]{NULL};
De esa forma las 5 posiciones del arreglo se inicializarían en NULL, o en su defecto con el valor que le asignes inicialmente.
