Wyświetlanie określonej ilości wyrazów ciągu fibbonaciego

Mam taki kod:

 #include <iostream>
#include <string>

using namespace std;

int main ()
{



int rozmiar=1;  //rozmiar ciągu - ilość elementów ciągu
 int ciag[rozmiar];  //tablica ciągu
 ciag[0]=1; ciag[1]=1;  // przypisanie 2 pierwszych wartości ciągu
 int iterator=0;

cin>>rozmiar;  // pobiera z klawiatury rozmiar ciągu (ilość elementów ciągu)

//pętla wyliczająca kolejny element ciągu fibbonaciego (oprócz elementu pierszego i drugiego)  - początek
for (iterator=(rozmiar-(rozmiar-2)); (rozmiar>2)&&(iterator<rozmiar); ++iterator)
{ciag[iterator]=ciag[iterator-2]+ciag[iterator-1];}
//pętla wyliczająca kolejny element ciągu fibbonaciego (oprócz elementu pierszego i drugiego)  - koniec


cout<<ciag[0]<<"   "<<ciag[1]<<"   "<<ciag[2]<<"   "<<ciag[3]<<"   "<<"\n";               // tymczasowe wyświetlanie wyznaczonych elementów ciągu
cout<<ciag[4]<<"   "<<ciag[5]<<"   "<<ciag[6]<<"   "<<ciag[7]<<"   "<<"\n"<<endl;   // tymczasowe wyświetlanie wyznaczonych elementów ciągu


// pętla wyświetlająca zawartość tablicy ciag (wyświetla wszystkie elementy ciągu fibbonaciego) - początek
for (iterator=0; iterator<rozmiar; iterator++)
{ cout<<ciag[iterator]<<endl; }
// pętla wyświetlająca zawartość tablicy ciag (wyświetla wszystkie elementy ciągu fibbonaciego) - koniec



	return 15;
}

Gdy, po uruchomieniu wpiszę np. liczbę 5
zwraca mi taki wynik :

5 - ilość elementów ciągu (rozmiar)
1 5 2 3 - tymczasowe wyświetlanie wyznaczonych elementów ciągu (błędnie)
5 0 0 0 - tymczasowe wyświetlanie wyznaczonych elementów ciągu (błędnie)

1 - pętla wyświetlająca
5 - pętla wyświetlająca
1912560752 - pętla wyświetlająca
32767 - pętla wyświetlająca
1912560752 - pętla wyświetlająca

Natomiast gdy z powyższego kodu usunę pętlę wyświetlającą zawartość tablicy ciag,czyli wyświetlającą wszystkie elementy ciągu fibbonaciego
(czyli usuwam to co poniżej), to kod działa prawidłowo.

// pętla wyświetlająca zawartość tablicy ciag (wyświetla wszystkie elementy ciągu fibbonaciego) - początek
for (iterator=0; iterator<rozmiar; iterator++)
{ cout<<ciag[iterator]<<endl; }
// pętla wyświetlająca zawartość tablicy ciag (wyświetla wszystkie elementy ciągu fibbonaciego) - koniec

Wynik tutaj:

5
1 1 2 3
5 0 0 0

Zera biorą się stąd, że ja mam tutaj wpisane wyświetlanie 8 elementów tablicy,
a w powyższym przypadku tablica liczy 5 elementów.

To proszę mi powiedzieć co jest błędne w pętli wyświetlającej zawartość tablicy ciag i
dlaczego jej dołączenie do kodu zmienia wartości wyświetlane przez polecenia cout oznaczone jako
"tymczasowe wyświetlanie wyznaczonych elementów ciągu". Co tu jest źle?
Jak by co to piszę na w Eclipse na OS X.

Nie zmieniasz nigdzie rozmiaru tablicy ciag - cały czas jej długość wynosi 1, więc bazgrzesz sobie po stosie.

#include <iostream>
using namespace std;
 
int main()
  {
   unsigned rozmiar;  // no chyba że spodziewasz ujemnych rozmiarów
   cin>>rozmiar;
   unsigned long long ciag[rozmiar];  // no chyba że spodziewasz ujemnych liczb fibbonaczego, lepiej jednak użyj `vector` lub przedziel poprzez `new`
   ciag[0]=ciag[1]=1;  // przypisanie 2 pierwszych wartości ciągu
   for(size_t iterator=2;iterator<rozmiar;++iterator) ciag[iterator]=ciag[iterator-2]+ciag[iterator-1];
   for(size_t iterator=0;iterator<rozmiar;++iterator) cout<<ciag[iterator]<<endl;
   return 0;
  }

#include <iostream>
#include <deque>

int fib(int x)
{
	if(x == 0)
		return 0;
	else if(x == 1 || x == 2)
		return 1;

	return fib(x - 1) + fib(x - 2);
}

int main()
{
	std::deque<int> numbers;
	int val = 0;
	std::cin >> val;

	while(val != 0)
		numbers.push_front(fib(val--));

	for(auto e : numbers)
		std::cout << e << " ";

	return 0;
}

http://ideone.com/NToX1Q

A ja mam pytanie, czy twoje zadanie ogranicza się do wypisania n pierwszych liczb tego ciągu? Bo jeżeli tak, to nawet nie musisz ich nawet spamiętywać ich (tworzyć tablicy, która jest wypełniana nimi). Prosta iteracyjna metoda pozwoli ci obliczać kolejne elementy i wypisywać je od razu przy wyliczaniu.

int a = 0, b = 1;
for (int i = 0; i < n; ++i)
{
	printf("%d ", a);
	b = a + b;
	a = b - a;
}

Jako ciekawostka, mozna tez zrobic strumien liczb i iterowac po nim.

trait Stream[+A] {
  def toList: List[A] = this match {
    case Cons(x, xs) => x() :: xs().toList
    case _ => Nil
  }

  def take(n: Int): Stream[A] =
    if(n > 0) this match {
      case Cons(x, xs) => Stream.cons(x(), xs().take(n - 1))
      case _ => Stream.empty
    }
    else Stream.empty

  def drop(n: Int): Stream[A] = this match {
    case Cons(x, xs) if n > 0 => xs().drop(n - 1)
    case _ => this
  }

  def foreach(f: A => Unit): Unit = this match {
    case Cons(x, xs) => f(x()); xs().foreach(f)
    case _ => ()
  }
}

case class Cons[A](x: () => A, xs: () => Stream[A]) extends Stream[A]
case object Empty extends Stream[Nothing]

object Stream {
  def cons[A](x: => A, xs: => Stream[A]): Stream[A] =
    Cons(() => x, () => xs)

  def empty[A]: Stream[A] = Empty

  def unfold[A, S](z: S)(f: S => Option[(A, S)]): Stream[A] =
    f(z) match {
      case Some((x, xs)) => cons(x, unfold(xs)(f))
      case None => empty
    }

  def fibs: Stream[Int] =
    unfold((0, 1)) { case (a, b) => Some((a, (b, a + b)))  }
}

object Main extends App {
  val fibNumbers = Stream.fibs.drop(8).take(4).foreach(println)
}