Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » CStringArray

C/Visual C - CStringArray

Volver
Nuevo Tema
<<>>
 
Vista:

CStringArray

Publicado por joselito (1 intervención) el 15/11/2001 07:28:27
Como hacer un array de double si no existe la clase CDblArray
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Crear un array de `double` sin `CDblArray`

Publicado por Alejandro (913 intervenciones) el 22/10/2024 20:52:47
Si no tienes acceso a la clase `CDblArray` en tu entorno de Visual C++, puedes crear un array de `double` utilizando un array estándar de C o C++. Aquí te muestro cómo hacerlo de varias maneras:

Opción 1: Usar un array estático



Si conoces el tamaño del array en tiempo de compilación, puedes usar un array estático:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
 
int main() {
    const int SIZE = 10; // Tamaño del array
    double myArray[SIZE]; // Declarar el array
 
    // Inicializar el array
    for (int i = 0; i < SIZE; ++i) {
        myArray = i * 1.1; // Asignar valores
    }
 
    // Imprimir los valores
    for (int i = 0; i < SIZE; ++i) {
        std::cout << myArray << std::endl;
    }
 
    return 0;
}

Opción 2: Usar un array dinámico



Si no conoces el tamaño del array en tiempo de compilación, puedes usar un array dinámico con `new`:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
 
int main() {
    int size;
    std::cout << "Ingrese el tamaño del array: ";
    std::cin >> size;
 
    // Crear un array dinámico
    double* myArray = new double[size];
 
    // Inicializar el array
    for (int i = 0; i < size; ++i) {
        myArray = i * 1.1; // Asignar valores
    }
 
    // Imprimir los valores
    for (int i = 0; i < size; ++i) {
        std::cout << myArray[i] << std::endl;
    }
 
    // Liberar la memoria
    delete[] myArray;
 
    return 0;
}

Opción 3: Usar `std::vector`



Si estás utilizando C++ y quieres una solución más flexible, puedes usar `std::vector`, que es parte de la STL (Standard Template Library):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <vector>
 
int main() {
    int size;
    std::cout << "Ingrese el tamaño del array: ";
    std::cin >> size;
 
    // Crear un vector de doubles
    std::vector<double> myArray(size);
 
    // Inicializar el vector
    for (int i = 0; i < size; ++i) {
        myArray[i] = i * 1.1; // Asignar valores
    }
 
    // Imprimir los valores
    for (int i = 0; i < size; ++i) {
        std::cout << myArray[i] << std::endl;
    }
 
    return 0;
}

Consideraciones



- [i]Array estático: Útil cuando el tamaño es conocido y pequeño.
- [i]Array dinámico: Útil cuando el tamaño es variable, pero debes gestionar la memoria manualmente.
- `std::vector`: Proporciona una forma segura y flexible de manejar [i]arrays dinámicos sin preocuparte por la gestión de memoria.

¡Buena suerte, Joselito!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar