16. Hafta

///////////////////////////////////////////////////////1. ders/////////////////////////////////////////

NULL pointer ne işe yarıyor ?


adres döndüren fonksiyonlar
---------------------------

başarılı veya başarıs olma durumuna göre NULL pointer döndüren fonksiyonlar :

-FILE * fopen(...) //başarısız olursa NULL pointer döndürücem
-void * malloc //başarısız olurs NULL pointer
-char * setlocal //başarısız olurs NULL pointer

int main(void) //NULL pointer en çok kullanıldığı yer
{
FILE* f;
FILE * fopen("bilgin.txt", "r");
if (f == NULL) //!f yazılabilinir{ 
fprintf(stderr, "cannot open file!\n");
return 1;
}
printf("file opened!\n");

fclose(f);
}

------

int main(void)
{
size_t n;

int* iptr = (int*)malloc(n * sizeof(int));
if (!iptr) {
fprintf(stderr, "cannot allocate memory'\n");
return 1;
}
}
--------

arama fonksiyonları :

search fonksiyonu genelde adres döndürür eğer yok ise o değer NULL pointer döndürür

NULL döndüren arama fonksiyonları :

strchr
strrchr
strstr
strpbrk
memchr
bsearch

int main(void)
{
char size [SIZE]

printf("BİR YAZİ GİRİN : ");
sgets(str);

char * p = strchr(str, 'a');
if (!p) { //NULL ise
printf("yazida a karakteri yok\n");
}
else {
printf("bulundu %d indisli karakter\n", p - str);
}
}

---------

aşağıda belirtilen fonksiyonu tanımlayınız 

eğer aranan değer dizide var ise onun adresini döndürücek
eğer aranan değer dizide yok ise NULL pointer döndürücek

int * search_in_array(const int * p, int size, int key){
for (int i = 0; i < size; ++i){
if (p[i] == key)
return (int*)p + i// (int*)&p[i]
}
return NULL;
}


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

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

int ival;
printf("aranacak degeri giriniz: ");
(void)scanf("%d", &ival);

int * p = search_in_array(a, SIZE, ival);
if (p != NULL){
printf("bulundu... %d dizisinin % indisli elemani\n", *p, p - a);
*p = -1;
print_array(a , SIZE);
}
else{
printf("aranan deger bulunamadi\n");
}
}

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

void bir türdür

!! bir değişkenin tipi void olamaz void x
!! bir diznin elemanlarının türü void türü olamaz
!! bir ifadenin türü void olabilir

türü void olan ifadeler :

void baz(int);

int main(void)
{
if (baz(12)) //geri dönüş türü void olan ifade kontrolde kullanılamaz
}


!! bir ifadenin türünü void türüne çevirebilirz

int main(void)
{
(void)foo(12); //fonksiyonun geri dönüş değerini kullanmak istemessem, bilerek discard edilirse kullanılır
}


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

int main(void)
{

}

!! öyle fonksiyonlar var ki pointer paramtere değişkenşne çağıran kodun NULL pointer geçmesi
opsiyon olarak sunuyor

-fonksiyon konuşuyor :
bana nesne adresi geçersen bu işi yaparım
bana NULL pointer geçersen şu işi yaparım

!! pointer paramtereye gelen NULL pointerı belgele 

a) bir fonksiyonun geri dönüş değeri adres ise NULL pointer döndürme ihtimali var mı diye bak

b)parametresi pointer olanlar için  eğer NULL pointer geçersem hata verir mi diye konrol et


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

NULL dangling pointerda kullanılır:

Pointer dangling hale geldiğinde NULL pointer yapılır

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



int main(void)
{
int* ptr;

if (1) {
int x = 12;

ptr = &x;
*ptr = 2453; 
} //burada ömrü biter

int ival = *ptr; //dangling pointer olur, 
}

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

defensive programming

//bir pointer dangling hale geldiğinde
//dikkat çeksin diye
ptr = NULL //yaparız

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

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

if (expr) {
ptr = nesne adresi
}
if (ptr)
}

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

======================================================
size_t : 
-------- 

sum_array(const int * p, size_t size); //int yerine size_t kullan
 
get_mean(const int * p, size_t size); //int yerine size_t kullan

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

C dilinde yazılar üzerinde işlem yapan fonksiyonlar :

!! aldığı adresteki yazıyı değiştirmek istemiyorsa aşağıdaki şekilde olmalı dizi boyu
int is_palindrom(const char * p)

//aldığı adresteki yazıyı std. çıkış akımına yazdıran 
sputs isimli bir fonksiyon tanımlayınız

----------

void sputs(const char * p)
{
for (int i = 0; p[i] != '\0'; ++i)
putchar(p[i]);
}
putchar('\n');
}

//2 şekilde yazılabilinir

void sputs(const char * p)
{
while (*p) //*p != '\n'
putchar(*p++);
putchar('\n');
}

int main(void)
{
char str[SIZE] = "bugun gunlerden pazar"
sputs(str);
}

--------

int str_count(const char * p, int x)
{
int cnt = 0;

while (*p){
if (*p == x)
++cnt;

++p;
}
return cnt
}

int main(void)
{
char str[SIZE] = "deneme bugra dene";
printf("%d\n", str_count(str, 'u'));
}


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

bir yazıyı bir yerden bir yere kopyalacayack 

void copy_str(char* pdest, const char* psource);

int maim()
{
char soruce[1000];
char dest[20];

copy_str(dest,source);  
}

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

#include <string.h>

strlen: Verilen bir karakter dizisinin uzunluğunu (karakter sayısını) hesaplar.
strchr: Bir karakter dizisinde belirtilen karakteri bulur ve ilk bulunan konumun adresini döndürür.
strstr: Bir karakter dizisinde belirtilen alt dizesini bulur ve ilk bulunan konumun adresini döndürür.
strcat: İki karakter dizisini birleştirerek, birinci karakter dizisinin sonuna ikinci karakter dizisini ekler.
strcmp: İki karakter dizisini karşılaştırır ve eşitlik durumunu kontrol eder.
strncpy: Bir karakter dizisini belirtilen uzunlukta kopyalar.
strncat: İki karakter dizisini belirtilen uzunlukta birleştirir.
strncmp: İki karakter dizisini belirtilen uzunlukta karşılaştırır.
strtok: Bir karakter dizisini belirli bir ayraç (delimiter) kullanarak parçalarına böler.
strerror: Bir hata numarasını açıklayıcı bir hata mesajına çevirir.
strspn: Bir karakter dizisinin başlangıcındaki karakterlerin belirtilen karakter kümesine kaç karakter uyduğunu bulur.
strcspn: Bir karakter dizisinin başlangıcındaki karakterlerin belirtilen karakter kümesine kaç karakter uymadığını bulur.

--------

strlen :

int main(void)
{
char str[SIZE];

printf("bir yazi girin: ");
sgets(str);

size_t len = strlen(str);
printf("uzunluk = %zu\n", len);
}

---------

int main(void)
{
char str[SIZE];

printf("bir yazi girin: ");
sgets(str);

size_t len = strlen(str);
for (size_t i = 0; i < len; ++i){
puts(str + i);
}
}

-------

strlen fonksiyonuun yazılması :

size_t strlen_1(const char * p)
{
size_t len = 0;

while (*p != '\0'){
++len;
++p;
}
return len;
}

size_t strlen_3(const char * p) //bu şekilde yazılabilinir
{
const char * ptemp = p;

while (*p)
++p;
return (size_t)(p - ptemp);
}

int main(void){
printf("bir yazi girin: ");
sgets(str);
size_t len = strlen(str);
printf("uzunluk = %zu\n",len);
}

------

strchr :

char * strchr(const char * str, int ch);

char str[SIZE];

printf("bir yazi girin: ");
sgets(str);
printf("girilne yazi :%s\n", str);
int ch;
printf("aranan karakteri girin: ");
ch = getchar();

char * p = strchr(str, ch);
if (p != NULL){
printf("bulundu" %s\n", p);
printf("yazinin %d indisli karakteri\n", p - str);
*p = '!';
printf("girilen yazi: %s\n",str);
}
else{
printf("bulunamadı\n");
}
}

--------

strchr fonksiyonun yazılması :

char * strchr(const char * p, int c)
{
for (int i = 0; p[i] != '\0'; ++i){
if (p[i] == c)
return (char *)(p + i);
}

if (c == '\0')
return (char *)(p + i);

return NULL;
}

--------
strrchr : 

char * strrchr(const char * p, int ch)

int main(void)
{
char str[];

printf("bir yazi girin : ");
sgets(str);
printf("girilen yazi: |%s|\n", str);

char * p1 = strchr(str, 'a');
char * p2 = strrchr(str, 'a');

if (!p1) {
printf("aranan karakter bulunamadi\n");
return 0;
printf("strrchr idx = %d\n", p2 -str);
}
}

----

int main(void)
{
char str[SIZE];

printf("bir yazi girin: ");
sgets(str);
printf("girilen yazi: |%s|\n", str);

char * p = strrchr(str, '\0');
*p++ = '!';
*p = '\0';

printf("|%s|\n", str);

}

------
strrchr fonksiyonunun yazılması :

char * strrchr(const char * p,int c)
{
const char * pfound = NULL;
while (*p != '\0'){
if (*p == c){
++p
}

if (c == '\0')
return (char*)p;

return (char*)pfound;
}

}


---------
strstr : yazi içinde yazi arama

char *strstr(const char *p1, const char *p2);

int main(void)
{
char str[SIZE];
char key[SIZE];

printf("içinde arama yapılcak yaziyı giin: ");
sgets(str);
printf("[%s]\n", str);
printf("aranacak yaziyi girin: ");
sgets(key);
printf("%s\n", key);
char * p = strstr(str,key);
if (p == NULL){
printf("bulunamadi);
return 0;
}

printf("bulundu index = %d\n",p - ptr);
size_t len = strlen(key);

strstr fonksiyonunun yazılmasi :

ödev
-----
while (len--)
*p++ = '!';
printf("[%s]\n", str);
}

///////////////////////////////////////////2. Ders/////////////////////////////////////////////////7
idioms:

char * p 

a) p bir yazıyı gösteriyor. Yani p'nin değeri bir yazının adresi
b) p NULL pointer


char * p
//eğer p bir yazıyı gösteriyor ise ve p'nin gösterdiği yazı boş değil ise

if (p != NULL && *p != '\0') //p'nin değeri yanlış ise 2. ifade sınanmıycak
if (p && *p); //yukarıdaki ile aynı anlama gelir 

//eğer p bir yazıyı göstermiyor ise ve p'nin gösterdiği yazı boş ise

if (p == NULL && *p == '\0') 
if (!p && !*p);

-------

// p yazının son ('\0') karakterinin adresini tutsun 

int main(void)
{
char str[SIZE] = "YUNUS";
char * p = str;
//amacım p'nin degerini null karakterin bulunduğu yerin adresi olsun
//bu yapıyı gösteren farklı idiom yapıları aşağıdadır

while(*p != '\0')
++p;

while(*p++ != '\0')
;
--p;

while(*++p != '\0') //tanımsız davranış
;

p = strchr(p, '\0); //bu şekilde de olur

p += strlen(p);

printf("%d\n", *p == '\0');
}

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

strcpy :

char * strcpy(char * pdest, const char *psource); //önce hedef(yazma) sonra kaynak(okuma)

bazı c fonksiyonları aldıkları adrese 
a) bir yazı yerleştiriyollar
b) yazıyı değiştiriyolar 


int main(void)
{
char source[SIZE];
char dest[SIZE];

printf("bir yazi girin: ");
sgets(source);

//source adresindeki (dizisindeki) yazıyı dest adresine (dizisine) kopyalayın

strcpy(dest, source);
printf("[%s] [%s]\n", source, dest);

}

----------

strcpy fonksiyonun yazılması :

char * mystrcpy(char * pdest, const char * psource)
{
char * pret = pdest;
while(*psource != '\0'){
*pdest = *psource;
++pdest;
++psource;
}
*pdest = '\0';
return pret
}

----------

char * mystrcpy(char * pdest, const char * psource) //aynı anlama gelir
{
char * pret = pdest;
while(*psource){
*pdest++ = *psource++;
}

while(*pdest++ = *psource++;) //aynı anlama gelir
;,{},continue //hepsi aynı anlama gelir

*pdest = '\0';
return pret
}

----

int main(void)
{
char str[SIZE] = "gulcan"
strcpy(str + 3, str);
//memmove(str + 3, str, strlen(str) + 1); ile mümkün
printf("%s\n", str); //tanımsız davranıştır, gulculgul
}

!! böyle durumlarda overlapped blocks denir 
kesişen - çakışan - arakesit olan bellek bloklar

-----------

strcat :
char * strcat(char* pdest, const char *psource);

int main(void)
{
char s1[SIZE] = "bugra"
char s2[SIZE] = "serttas"

strcat(s1,s2);
printf("%s\n", s1); //
}

----------

strcat yazılması :

char * mystrcat(char * p1, const char* p2)
{
char * pret = p1;
while(*p1)
++p1;

while(*p1++ = *p2++)
;

return pret;
}

--------

char * mystrcat(char * p1, const char* p2)
{
strcpy(strchr(p1, '\0'), p2);
return p1;
}

----

char * mystrcat(char * p1, const char* p2)
{
strcpy(p1 + strlen(p1), p2);
return p1;
}
//3 kodda aynı işlemi yapar

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

strcmp :

yazılan eşitlik, eşitsizlik, relational

a    b
a  > b
a  < b
a == b

//1. yazı büyükse pozitif ikinci yazı büyükse negatif eşit iki sayı eşit ise 0 döndürür

int cmp_xyz(T x, T y)
retval > 0
x > y
retval < 0
x < y
retval = 0
x == y

lexicongraphical compare algoritması:

7
2 3 4 7 9
// yukarıdaki daha büyük eleman sayısının az olmasına rağmen (7 > 2)

su //
cumhuriyet //bu daha önce gelir sözlükte (lexicongraphical compare)

int main(void)
{
char s1[SIZE];
char s2[SIZE];

if (strcmp(s1, s2) == 0){
}

if (!strcmp(s1, s2)){ // 2 yazı birbirine eşit ise
}

if (strcmp(s1, s2) != 0){ // 2 yazı birbirine farklı ise
}

if (strcmp(s1, s2) < 0){ // s2, s1'den büyük ise
}

if (strcmp(s1, s2) > 0){ // s1, s2'den büyük ise
}
}

int main(void)
{
char s1[SIZE];
char s2[SIZE];

printf("iki yazi girin: ");
scanf("%s%s", s1,s2);
int cmp_result = strcmp(s1,s2)

if (cmp_result > 0){
printf("%s > %s\n", s1,s2);
}
else  if (cmp_result < 0){
printf("%s < %s\n", s1,s2);
}
else 
printf("%s == %s\n", s1,s2);
}

printf("cmp_result = %d\n",

------
strcmp kodunun yazılması :

int mystrcmp(const char* p1, const char * p2)
{
while(*p1 == *p2){
if (*p1 == '\0'){
return 0;
}
++p1;
++p2;
}
return *p1 - *p2 //p1 - p2 yazsa idik adresleri birbirinden çıkarırdık hata olurdu 
}

----------

strpbrk : yazının içind birden fazla kelime aramayı sağlar
char * strpbrk(const char * p,const char *pchars);
 

int main(void)
{
char s1[SIZE];
char s2[SIZE];

printf("bir yazi girin: ");
sgets(str);

printf("aranacak karakterler: ");
scanf("%s", s);
printf("[%s]  yazisindaki [%s] \n karakterlerinden birini arıyorsunuz\n, str, s);

char * p = strpbrk(str, s);

if (p != NULL){
printf("bulundu yazinin %d indisli karakteri\n" p -str);
}else
printf("buunamadi");
}

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

bir yazının sonunda baika bir yazı var mı sorusunun ceavabını almak

int ends_with(const char* p1, const char * p2);
{
size_t  len1 = strlen(p1);
size_t  len2 = strlen(p2);

if (len2 > len1){
return 0;
}
return !strcmp(p1 + len1 - len2, p2);
}

 
int main(void)
{
char s1[SIZE];
char s2[SIZE];

printf/"birinci yaziyi girin: ");
sgets(s1);
printf("ikinci yaziyi girin: ");
sgets(s2);

if (ends_with(s1, s2)){
printf("evet var\n");
}
else{
printf("r yok\n");
}
}

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

bu konular biraz zor daha dikkatli bak:

-string literals (2 - 3h)
-pointer arrays ( min 3h)
-pointer to pointer(min 3h)
-void pointers (min 4h)
-function pointers (min 6h)
-multi-dimensional arrays (min 4h)
-dynamic memmory management (min 6h)


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

string literals :
-----------------

int main(void){
char * p = "murat"; //char türden bir dizinin adresşni tutarız aslında
//yukarıdaki kodda derleyicinin oluşturduğu char dizinin
//adresini p pointer değişkenine ilk değer vermiş oluyoruz
}

int main(void){
printf("%c\n", *"YUNUS"); //Y yazar ekrana
printf("%c\n",  "FURKAN"[3]); //K
printf("%c\n",  "FURKAN" + 3); //K
printf("%c\n",  "erenkaan"); //adresini yazar

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

for (int i = 0; i < 10; ++i){
printf("%p\n", "necatiergin"); //hep aynı adresi yazar
}
}

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

for (int i = 0; i < 10; ++i){
printf("%p\n", str); //hep aynı adresi yazar, yukarıdakinden farkı yok aslında
}
}

---------

!! string literali olan diziler "statik ömürlüdür"

!! string literali olan diziler salt okuma amaçlı kullanılmalıdır
!! Bu yazıların değiştirilme girişimi tanımsız davranış

------

int main()
{
printf("merhaba dunya"); //programın başından sonuna kadar kalacaktır
}

------

char *func(void)
{
char str[100];
//code

return str; //ub var, str otomatik ömürlü
}

int main(void)
{

}

------

char *func(void)
{

return "aliosman"; //ub yok sttaik ömürlğ
}

int main(void)
{
char*p = func();

}
------

char * get_weekday_name(int dayno)
{
switch(dayno){
case 1: return "pazar";
case 2: return "pazartesi";
case 3: return "sali";
case 4: return "çarşamba";
case 5: return "perşembe";
case 6: return "cuma";
case 7: return "cumartesi";
}
return "";
}

int main(void)
{
for (int i = 1; i <= 7; ++i){
puts(get_weekday_name(i));
}
}

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

int get_hex_char(int val);
{
return "0123456789ABCDEF"[val]; 
}

int main(void)
{
for (int i = 0; i < 16; ++i){
putchar(get_hex_char(i));
}
}

-----------

!! c'de yapılan en sık ypılan hatalardan birisis string literallerini değiştirmektir

---------

int main(void)
{
char * p = "mert";
*p = 's'; //tanımsız davranıştır string literalleri asla değiştirilemez
puts(p);
}

----------

int main(void)
{
char * p = "metehan serttas";

strcpy(p, "bugrahan serttas"); //ub olur değişmez 
}

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

!! asla paramteresi char * olan bir fonksiyonun paramteresine argüman olarak 
bir string literali göndermeyin

!! ancak paramteresi const char *  olan bir fonksiyona string literai göndermenizde sakınca yoktur

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

int main(void)
{

char name[SIZE];

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

if (!strcmp(name, "alican")) {
printf("hos geldiniz alican\n");
}
else {
printf("sen alican degilsin, mekana giremessin\n");
}

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

int main(void)
{

char name[SIZE];

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

strcat(name, "can");
printf("artik isminiz %s oldu\n", name); //ub yok
}

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

int main(void)
{
const char* p = "murat";

*p = 'S'; //c'de sentax hatası değil ancak ub olur o yüzden const kullan

}

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

!! tüm zamanların en çkok sorulan mülakat sorularından

int main()
{
char str[] = "bilgin";

str[0] = 'y';  // burada ub yok burası çok önemli
}

--------------
!! 

int main()
{
char* p = "bircan";
char str[] = "necati";

p[3] = 's'; // UB
str[2] 'm'; // LEGAL

}

---------------
!! unspecified behavier (ne olacağı belli değil)

int main()
{
char* p1 = "furkan"; //1ac4
char* p2 = "furkan"; //1ac4 

if (p1 == p2)
printf("evet esit!!!\n");
else
printf("hayir esit degil!!!\n");

}

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

int main()
{
char* psw = "purple rain";

if (psw == "purple rain") {

}
}

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

char str[] = "bugra"; //1 tane değişken oluşturuldu
str[0] = 'y'; hata olmaz
char * p = "bugra"; //2 tane değişken oluşturuldu
p[0] = 's'; //hata olur