//
// Cok basit ve pratik amaclar icin vector<> kullanimi
//
// UYARI: asagidaki kod parcalarinin nasil ve neden calistigini
// anlamak icin templateler ve STL (en azindan container classes, iterators) konularini
// arastiriniz. Cok seveceksiniz :) Tabii ki temel C++ kaslarimizi da mutemadiyen 
// calistirmaliyiz. Umarim yararli olur ;)
//

//
// temel duzeyde vector<> sinifinin kullanimi
// vector, istediginiz kadar veri ekleyebildiginiz bir cesit array yapisidir.
// template olarak tasarlanmistir ve herhangi bir tip icin kullanabilirsiniz.
// yeni veriler eklendikce (gerektiginde) kendini genisletir.
// ayrica asiri yuklenmis [] operatoruyle ona siradan bir diziymis (örn. cout << v[10])
// gibi davranabilirsiniz. ama kalbimizdeki yeri her zaman baskadir. :)
//
#include <iostream>
#include <vector>

using namespace std;

int main()
{
	// int saklayan bir vector
	vector<int> int_vec;

	// veri ekleme
	for(int i = 0; i < 10; i++)
		int_vec.push_back(i);

	// veriler üzerinde iterasyon (dolasim) iteratorler ile saglanir
	// iteratorlerin calisma sekli pointerlara benzer
	//
	// operator *
	// iteratorun bulundugu pozisyondaki elemani verir
	// eger bu elemanin uyeleri varsa (bir class ya da struct ise) -> operatorunu direkt
	// olarak kullanabilirsiniz.
	//
	// operator ++
	// iteratorun bir sonraki elemana ilerlemesini saglar. cogu iterator ayni zamanda
	// geriye dogru gitmeyi de destekler (-- operatoru ile)
	//
	// operator =
	// bir iteratorun pozisyonunu baska bir iteratore atar.
	// (iteratorun gosterdigi nesneyi degil sadece pozisyonunu :) )
	//
	// operator == ve !=
	// iki iteratorun ayni pozisyonu isaret edip etmediklerini test etmek icin kullanilirlar

	vector<int>::iterator iter;
	// iterator bu sekilde tanimlaniyor.

	// :: bildiginiz gib kapsam cozunurluk operatorudur.
	// vector<int>::iterator ifadesindeki iterator kelimesi
	// vector<> classi icerisi bir typedef dir 
	//
	// nasil ki vector<> sablonu
	// belirttiginiz tipte gercekleniyorsa onunla beraber iterator typedefi de
	// vectorun bir uyesi olarak o tipte gerceklenir. (sinifin bir uyesi oldugu icin)
	//
	// fikir vermek amaciyla:
	//
	// template <typename T,.... >
	// class vector
	// {
	//   ...
	//   typedef biseyler ... iterator; 
	// };
	//
	// gibi..
	//
	// yani vector<int>::iterator demek
	// ben int vector unun iteratorunu istiyorum demektir.

	// begin() uye fonksiyonu vector un ilk elemanina isaret eden bir iterator dondurur
	// end() uye fonksiyonu ise vectorun - son elemanindan bir sonrakine - 
	// isaret eden bir iterator dondurur. yani iterator end()'e esitse durmaliyiz :)
	// *end() gecersiz bir nesnedir
	//
	// mesela int dizi[10] diye bir arrayimiz var
	// ve soyle bir for dongusu yaziyoruz
	// for(int i = 0; i < 10; i++)
	//     dizi[i] = 0,
	// son elemanin indisi 9dur. i degiskeni 10 degerini aldiginda donguyu bitiriyoruz
	// cunku dizi[10] = 0; gibi bir islem hatalidir. son eleman 9. elemandir
	// 10. eleman demek sondan bir sonraki demektir. (hata ! kötü ! :) )
	//
	// end()'in neden son elemandan bir sonraki noktaya isaret ettigini umarim anlatabilmisimdir.
	// (ya da anlatmakla kafanizi karistirmamisimdir. :) )

	for (iter = int_vec.begin(); iter != int_vec.end(); ++iter)
		cout << *iter << " ";
	cout << endl;

	// veri silme
	
	int sira = 3; // 3. tamsayiyi (yani 2) vectorden sil
	iter = int_vec.begin() + sira - 1;
	int_vec.erase(iter);

	// erase() fonksiyonu parametre olarak bir iterator alir
	// ve o iteratorun isaret ettigi nesneyi diziden siler

	// erase() e parametre olarak gectiginiz bir iterator degiskeni artik gecersiz
	// bir nesneye isaret edecektir dikkatli olun
	// cout << *iter; ---> HATA ! (ve o rahatsiz edici ses :) )

	for (iter = int_vec.begin(); iter != int_vec.end(); ++iter)
		cout << *iter << " ";
	cout << endl;

	
}