imprimir elementos "no vacios" de un array

Question

estoy probando los punteros y las funciones en c y quiero intentar hacer una funcion que me retorne la succecion de fibonacci hasta el numero 10000. Este es el codigo:

#include <stdio.h>
void fibonacci(int *ar);

int main(void){
    int arr[256];

    fibonacci(arr);       

    for(int m:arr){        <----
        printf("%d\n", m);
    }
    return 0;
}

void fibonacci(int *ar){
    int x = 1, y = 0, z = 1;
    int a = 0;

    *(ar+a) = 0;
    while(x <= 10000){
        *(ar+a) = x;
        a++;
        x = z + y;
        y = z;
        z = x;
    }
}

exactamente la linea marcada con una flecha tengo un for donde recorro todo el array, pero en lugar de mostrar solo la sucesion, me muestra los 256 espacios de la memoria asignados para arr. ¿como puedo hacer para mostrar solo la sucesion?

Answer 1

El bucle for de rango, existe en C++ desde el estándar de 2011 y tiene la forma:

for (variable : colección)

Su característica es que recorre toda la colección sin necesidad de la verborrea del bucle for tradicional equivalente:

for (auto b = begin(colección), e = end(colección); b != e; ++b)

El problema es que si quieres un bucle que no recorra toda la colección, el bucle for de rango no debería ser tu primer candidato.

Tus alternativas son:

• Cambia a bucle tradicional:

  for (int b = 0, e = fibonacci(arr); b != e; ++b)
      std::cout << arr[b] << '\n';
  

• Inicializa la formación a cero y fuerza el abandono del bucle si el valor no es cero:

  int arr[256]{0}; // <--- Todos los valores de 'arr' a cero.
  
  fibonacci(arr);
  
  for (int m : arr)
      if (m) std::cout << m << '\n';
      else break;
  

• Usa un contenedor de datos de tamaño variable, en lugar de una formación de tamaño fijo.

  void fibonacci(std::vector<int> &ar){
      int x = 1, y = 0, z = 1;
  
      while(x <= 10000){
          ar.push_back(x);
          x = z + y;
          y = z;
          z = x;
      }
  }
  
  int main() {
      std::vector<int> v;
      fibonacci(v);
  
      for (int m : v)
          std::cout << v << '\n';
  
      return 0;
  }
  

Otras cosas a tener en cuenta.

• La cabecera <stdio.h> es del lenguaje c y no debe ser usada en c++, si realmente tienes la necesidad de usarla (cosa muy improbable) deberás usar la versión adaptada a C++: <cstdio>. Lee este hilo para saber más.
• En C++, las funciones que no reciben parámetros, se definen con una lista vacía de parámetros no con void en la lista de parámetros: es int main() no int main(void).
• La función printf pertenece a las rutinas de C, en C++ se usa el objeto std::cout para escribir datos en la consola.

Answer 2

No se si es necesario crear una formación de 256 elementos si solo vas a imprimir unos cuantos, además, no hay elementos "no vacíos" como dices en el título sino más bien elementos inicializados y no inicializados, los elementos no inicializados quedarán con valores residuales de memoria. En C++ podrías inicializar a cero los elementos de tu formación con algo como:

int arr[256]{};

y para imprimir solo los elementos que la función modificó:

   for(int m:arr){//Esta sintaxis no funciona en C
    if (m==0)
       break;
    else
      printf("%d\n", m);
    }

Pero hacerlo así no es recomendable, lo mejor sería declarar la formación con la cantidad exacta de elementos que vas a almacenar.

Answer 3

Podrías hacer que la función fibonacci devuelva el número de elementos que fueron asignados al arreglo y luego iterar hasta ese numero:

#include <stdio.h>
int fibonacci(int *ar);

int main(void){

    int arr[256];

    int n=fibonacci(arr);       

    for(int i=0;i<n;i++){        <----
        printf("%d\n", arr[i]);
    }
    return 0;
}
int fibonacci(int *ar){
    int x = 1, y = 0, z = 1;
    int a = 0;

    *(ar+a) = 0;
    while(x <= 10000){
        *(ar+a) = x;
        a++;
        x = z + y;
        y = z;
        z = x;
    }
    return a;
}