15. Hafta

 ///////////////////////////////////////////////////1. Ders///////////////////////////////////////////

int main(void)
{
int a[10] = {0, 1,2,3,4,5,6,7,8,9};
int * pe = a + 10; //diref edemem ama pointer değişkenin bu adres olmasının herhangi bir sakıncası yoktur
int * p = a;

while (p != pe){
printf("%d ",*p); //bir diziyi bu şekilde de dolaşabiliriz
++p;
}
} 

-------

int main(void)
{
int a[10] = {0, 1,2,3,4,5,6,7,8,9};
int * p1 = a + 5; //5. elemanı (değeri değil direkt 5)
int * p2 = a + 8; //8. elemanı (değeri değil direkt 8)

if (p2 > p1){//  DOĞRU 8 > 5
}

}

-----

void printArray(const int* pfirst, const int* plast)
{
while (pfirst != plast){
printf("%d ", *pfirst++);
}
printf("\n---------------------\n");
}

int main(void)
{
printf_array(a, a + 10);
}

------
//artesitik bir şekilde yazılması :)

void reverseArray(int * p, int size)
{
int * pe = p + size
while (p < pe)
swap(p++, --p);
}

int main(void)
{
int a[SIZE];

randomize();
set_array_random(a, SIZE);
print_array(a, SIZE);
reverse_array(a, SIZE);
print_array(a, SIZE); 

}


=================================================

pointer idioms :
----------------

pattern (dilden bağımsız, c de de c++'da da java da da yapılabilir)
idiom (dile bağımlı)
technic (alışılmış konuyu ele alma biçimi)

// önce ufask bir tekrar

- içerik operatörü ile oluşturulan ifade L value expressiondur

- L value olduğunu tespit etmek için başına '&' koyulduğu zaman hata vermiyor ise L value

&x++   illegal   çünkü adres operaörünün operandı olan ifade L value değil
&++x   illegal   çünkü adres operaörünün operandı olan ifade L value değil
++&x   illegal   çünkü ++ operando olan ifade L value değil

---------------------------------

expression ile statement farkı

x + 5  //expression
x + 5; //expression statement
x; //expression statement
5; //expression statement
; //null statement
if (x > 10) ++y; //if statement

expression çeşitleri:

statement
expression statement
control statement
null statement
compound statement
  loop stateemnt
  jump statement

----------------------------------------

int main(void)
{
int a[5] = {10, 20, 30, 40, 50);
int * p = a;
*p++ = 33; //33 değeri dizinin ilk elemanına atannır
*p = 77; //side effecten dolayı dizinin 2. elemanı 77 olur

*p++ //p'nin gösterdiği nesneye eriş p'yi 1 arttır
}

*p++ = 10;
//ikiside aynı anlamda (yukarıdaki tercih edlir)
*p = 10 
p = p + 1;
---------------

int main(void)
{
while(size--){        
*p++ = rand() % 1000;
}
}
//ikiside aynı anlamda (yukarıdaki tercih edlir)
while(size--){
*p = rand() % 1000;
p = p + 1; //aynı anlama gelir yukarıdaki ile
}
}

-------------

int main(void)
{
int a[5] = {10 ,20 ,30 ,40 ,50};
int * p = a;
*++p = 99; //dizinin 2. elemanına atama olur
}

--------------

int main(void)
{
int a[5] = {10 ,20 ,30 ,40 ,50};
int * p = a + 4
*++p = 90; //hata verir dizi eleman sayısı taşar

}

-------------- 

int main(void)
{
int a[5] = {10 ,20 ,30 ,40 ,50};
int * p = a;
++*p; //a dizisinin ilk elemanını 1 arttırır 
(*p)++ //a dizisinin ilk elemanını 1 arttırır 
!! son ek olarak arttırak istiyorsan parantez zorunlu
!! ön ek olarak arttırmak istiyorsan parantez zorunlu deği
}


------------------------

void reverse_copy(int * pdest, const int * psource, int n);
{
const int * pe = psource + n;
while (n--)
*pdest++ = *--pe;
}

int main(void)
{
int a[SIZE];
int b[SIZE];

randomize();
set_array_random(a ,SIZE);
print_array(a, SIZE);
reverse_copy(b, a, SIZE); //dizinin tersini bir yere kopyalar
}

----------------------

/*
void func(int* p, int size)
{
while (size--)
++*p++;
}
*/


======================================================


typdef bildirimleri (tür eş bildirimleri / type alias declarations) : 

takma isim anlamına gelir

buğrahan ==> buğra


double x = 3.45;

meter distance = 3.45; //bu daha anlaşılır

!! var olan bir türe onu temsil edicek eş isim verilir

-----
typedef int (*FPTR)(const char *, const char *)

int(*func(int (*fp1)(const char *, const char *), int (*fp2)(const char*, const char*)))const char *, const char *);

FPTR func(FPTR, FPTR); //187. satır ile aynı anlama gelir
-----

neden kullanılırz:

1- Tam sayi ve gerççek sayı türlerinin "çok genel" olma özelliği yerine bunları daha daraltılmış
bir bağlamda kullandığımız göstermeye yönelik

2- Karmaşık türlerin (yani bildiriminde fazla sayıda token kullanılan) kullanımı kolaylaştırmak için

3- kodun taşınmasını kolaylaştırmak için


typedef int Word; //int türüne Word eş ismini verdik

int main(void)
{
Word x;
Word * p;
Word a[10] = {0};
}

-------

typedef int * IPTR;

int main(void)
{
IPTR p; //int * p;
}

-----
typedef const int * CIPTR
int main(void)
{
CIPTR p1, p2;
}

------------
!! özellikle karmaşık bildiirmlerde işimizi kolaylaştırmak için typedef bildirimi yapmanın pratik yolu :

1- hangi türe eş isim vermek istiyorsanız o türden bir değişken tanımla
2- tanımalama başına typedef anahtar sözcüğü koy
3- değişkene verdiğimiz ismi silin onun yerine seçtiğimiz türe eş ismini koyun

int x;e
typedef int x;
typedef int
typedef int word;

----------------
int [20] ==> INTA20

int a[20];
typedef int a[20];
typedef int [20]
typedef int INTA20[20]

INTA20 x,y,x;
int x[20], y[20], z[20];

!!define makrosundan farkı

#define MYPTR int *
typedef int * IPTR;

int main(void)
{
IPTR p1, p2; //p1 ve p2 pointer
MYPTR p3, p4; //yalnızca p3 pointer
}

----------------

typedef int * IPTR;

int main(void)
{
int x = 10;
const IPTR p = &x;

//int *const p = &x; // cevap bu olmalı alttaki olmaz
//const int *p = &x; // 

p = &y; legal değil
*p = 34; legal

}


/////////////////////////////////////////////////////////////2. Ders///////////////////////////////////////////////

standart tür eş isimleri (standard type aliases)

size_t
ptrdiff_t
clock_t
time_t
fpos_t
int32_t
int64_t

------------------------ 

size_t : sizeof operatörünün ürettiği değerin türü, türe verilen eş isim (int unsigned int vb. //derleyiciye bağlı)

standart kütüphane size_t eş ismini hangi durumlarda kullanır :

1- yazı uzunluğu türü
  strlen strspn strspsc

2- dizi boyutu türü (array size)
  qsort, bsearch

3- sizof değeri bekleyen parametlerin türü

4- tane - adet 

int main(void)
{
  size_t x = 10; //isim değildir identifier'dır yer aldığı başlık dosyasını <stddef.h> include etmemiz gerekir
}

int main(void)
{
ptrdiff_t //pointer difference type, 2 pointerın çıkarırken bunu kullan
}

int main(void)
{
printf("%zu", sizeof(int)); //sizeof kullanıldığı zaman %zu kullanılabilinir. 
// size_t hangi türün eş ismi ise %zu sayesinde ona uyum sağlar
}

!! bir byte her zmaan 8 bit değildir, değişeilir bu değer limits başlık dosyasındakiş CHAR_BIT'ten öğrenilir

bu yüzden aşağıdaki kullanılır garanti sapğlamak için (16 bit kullanıcaksak uint16_t kullan)

#include <stdint.h> //c99 ile gelen bu kütüphaneyi include ederek kullanılır



int16_t, int32_t ve int64_t standart typdef isimleridir c99 ile eklenmiştir. opsiyoneldir (derleyici vermeyebilir)

uint16_t //16 bitlik unsigned int türü (optiona)

int_least16_t x; en az 16 bitlik tam sayı bitini tutabilir

int_fast16_t x; 16 bitlik tam sayılarla işlemin en hızlı yapıldığı türün ismi


!! asla standart kütüphanenin bir başlık dosyasında değişiklik yapmayın

================================================

adres döndüren fonksiyonlar (functions returning pointers) :
------------------------------------------------------------- 

int * foo(void) //foo öyle bir fonksiyonki türü  int nesnenin adresini döndürüyor

int main(void)
{
  int * ptr = foo(); //foo neyin adresini döndürürse ptr onu göstericek
}

int bugra(void) // geri dönüş değeri int
int * bugra(void) // geri dönüş değeri adres

-----

int g = 567;

int * foo(void)
{
return &g;
}
   

int main(void)
{
int * p = foo() //*p g'nin değerini tutar
++*foo(); // g'nin d eğeri 1 artar
int * p1 = foo(); //g'nin değeri gözükür
int * p2 = foo(); //g'nin değeri gözükür
int * p3 = foo(); //g'nin değeri gözükür
}

------

int a[5] = {10 ,20, 30, 40 ,50};

int * foo(void)
{
return a;
}

int main(void)
{
++foo()[3]; //3 indili elemanın dğerini 1 arttırır
}
-----------

!!!!!!

int * get_value(void)
{
int x; //static olmalıydı burası
printf("bir tam sayi girin: ");
scanf("%d", &x);

return &x; //otomaitk ömürlü değişken geri dönüş değeri olarak kullanılamaz, DANGLİNG POİNTER
}

int main(void)
{
int * ptr = get_value();
printf("%d ", *ptr); //tanımsız davranış dangling pointer olur x değişkenin ömrü biter
}

!! ÇOK DİKKAT ET !!
adres döndüren bir fonksiyon otomatik ömürlü bir yerel değişkenin adresini döndürmemeli.

----------

char * get_name(void){
char str[100]; //otomatik ömürlüdür tanımsız davranıştır 

printf("isminizi giriniz: ");
scanf("%s", str);
}

int main(void)
{
char * p = get_name();
printf("isminiz %s\n", p);
}

-------

// 3 pointerda 90 değerini gösterir çünkü x değeri tekrar hayat gelmez

int* get_value(void)
{
static int x;
printf("bir tam sayi girin: ");
scanf("%d", &x);

return &x;
}

int main()
{
int* p1 = get_value();
int* p2 = get_value();
int* p3 = get_value();

printf("%d\n", *p1);
printf("%d\n", *p2);
printf("%d\n", *p3);

}


------------


char * get_name(void)
{
char str[100]; //otomatik ömürlü

printf("isminizi girin");
scanf("%s", str);

return str;
}

int main(void)
{
char* p = get_name();
printf("isminiz %s\n", p); //ub olur
}

-------------

int * foo(int * p)
{
++* p;
return p;
}
//tanımsız davranış yoktur
int main(void)
{
int x = 99;
int * ptr = foo(&x);
printf("*ptr = %d\n", *ptr); //cevap = 100
}

---------

int * foo(int * p)
{
++p;
++p;
return p;
}

int main(void) // tanımsız davranış yok
{
int a[5] = {10, 20 ,30, 40, 50};
int * p = foo(a);
*p = 999;
print_array(a,5); //dizinin 3. elemanının değeri 999 olur
}

------------

int* foo(void)
{
int x = 10;
int* p = &x;

return p; //hatalı x'in adresini döndürür ancak x otomatik ömürlü
}

------------

int* foo(int *ptr)
{
int* p = ptr;

return p; //bu şekilde hata olmaz
}

------------

adres döndüren bir fonksiyon :

a) statik bir ömürlü nesnenin adresini döndürebilir
  -global bir değişkenin adresi
  -static yerel bir değişkenin adresi
  -string literalleri

b) dinamik ömürlü bir nesne adresi 

c) fonksiyon çağıran koddan aldığı adresi çağıran koda geri döndürebilir

-----

int main(void)
{
int a[SIZE];

randomize();
set_array_random(a, SIZE);
print_array(a, SIZE);
int max = get_array_max(a, SIZE);

printf("max = %d\n", max);

max = -1;

printf_array(a, SIZE); //DEĞERİ DEĞİŞMEZ ADRES DÖNDÜRMEDİĞ İÇİN
}


-----

int * get_array_max(const int * p,int size)
{
int * pmax = p; //dizinin ilk elemanın adresini pmax'ta sakladık, c++'da bu hata const'tan const olmayana hata olur c de uyarı mesajı verir
//int* pmax = (int *)p; //bu şekilde yazabiliriz
for (int i  = 1;i <size; ++i){
if (p[i] > *pmax){
pmax = p + i; //&p[i] bu şekilde de olabilirdi
//pmax = (int *)p + i; //aynı şek,ilde burada da bunu yapmalıyız
}
}
return pmax;
}

int main(void)
{
int a[SIZE];

randomize();

int * pmax = get_array_max(a, SIZE);

printf("max = %d ve dizinin % indisli elemani\n", *pmax, pmax - a);

*pmax = -1; //dizinin max elemanını şimdi -1 yaptık
}


--------

!! const nesne  adresi türünden örneğin T bir tür olmak üzere
const T * türünden const olmayan nesne türüne yani örneğin T* türüne 

a) c++ dilinde örtülü dönüşüm yoktur
b) c dilinde böyle bir dönüşüm örtülü olarak yapılır ancak bir önlem alınmaz ise kodun okuyucusu bu dönüşüm yanlışıkla yapıldığını dönüşür
C derleyicilerinde böyle bir örtülü dönüşüm yapılması durumunu şüpheyle karşılayarak uyarı mesajı verirler

C dilinde böyle dönüşümleri bilerek istiyerek yapıyor isek mutlaka ve mutlaka tür dönüştürme operatörünü (type - cast) kullanmalıyız


------------

int * foo(void);
void bar(int*);

int main(void)
{
bar(foo());
}

----------

int main(void)
{
int a[SIZE];

printf_array(a, SIZE);
int * pmax = get_array_max(a, SIZE);

printf_array(a, pmax - a + 1); //dizinin max elemanına kadar(max ile beraber) ekrana yazdırır
}

--------------
selection sort algoritmasının yazılması

void selection_sort(int * p,int size)
{
for (int i = 0; i < size - 1; ++i){
swap(p + 1, get_array_min(p + i, size - i)); //selection sort algoritmasını yapar  
}
}


  
====================================================

NULL pointer :

-Büyük harfle yazılmıi NULL keyword değildir. Bir makrodur
yani önişlemci programa tanıtılan bir isimdir yani bir sebolik sabittir.

-Bu makro C dilinin standart kütüphanesinin bazı başık dosyalarında define edilmiştir

<stdef.h>
<stdio.h>
<sting.h>
<stdlib.h>
<time.h>

özellikleri :

1) bu makroya NULL pointer olarak söyle

2) Büyük harf ile yazılan NULL bir addrestir bu adres sadece pointer değişkenkere atanmalıdır /
ilk değer olarak asla (legal olsa da) pointer olmayan değişkene  NULL ataması yapma

int x = NULL; //Böyle bir şey yapma

ancak NULL pointer herhangi türden bir pointer değişkene atanabilir:

int * ip = NULL;

3) NULL pointer hiçbir nesnenin adresi değildir ama geçerli bir adrestir
örneğin bir pointer değişkenin değeri NULL olabilir
Hiçbir nesneyi göstermeyen ancak geçerli pointer.

4) NULL pointer hiçbir nesnenin adresi olmadığı için dereference edilmemelidir
yani * operatorünün ya da [] operatörünün yapılmamalıdır (UB)

int main(void)
{
int * p = NULL;

//*p (UB)undefined behavier
//p[3] (UB)
}

Benzer şekilde NULL poiner adresinin toplama, çıkarma gibi işlemlerde kullanılmamalıdır

5) statik ömürlü bir değişekene ilk değer vermediğizde hayata 0 ile başlar
static ömürlü pointer değişkene hayata NULL pointer değeri ile hayata başlar

int * ptr //ptr has NULL value
static int * ptr //ptr has NULL value

6) iki adres eşitlik kaşılaştırılmasına sokulduğunda eğer iki adres de NULL pointer
değerine sahipse doğru sonuç verir

7) C ve c++ dillerinde lojik ifade beklenen yerlerde bir adres ifadesi kullanılabilinir

adres NULL pointer ==> false
adres NULL pointer değil ise ==> true

if (ptr != NULL)
if(ptr) //üstteki ile aynı anlamda

if (ptr == NULL)
if(!ptr) //üstteki ile aynı anlamda

8) Normal olarak bir pointer değişkene bir adres atanmalıdır

bir pointer değişkene adres olmayan bir verinin atanması örneğin bir tam sayı değerinin atanması yanlıştır
Böyle bir atama c++ dilinde (zaten) sentaks hatasıdır. C derleyicileri uyarı verir
ancak bu durumun bir istisnası vardır eğer bir pointer değişkene tam sayı sabiti olarak 0 atanır ise bu durumda
derleyici 0 tam sayı sabitini NULL pointer'a dönüştürür
bu dönüşüme NULL pointer conversion denir

int * p = 0; //hata vermez derleyici NULL olarak algılar
int * p = NULL; // bu şekilde görür

9) bir dizinin boş indisleri NULL karakter ile başlar