21. hafta

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

//statik ömürlü nesne adresi döndürsün
//her defasında aynı parola döner çünkü aynı adrese yazar statil ömürlü olduğu için

char * get_random_psw(void);
{
static char str[40];
int len = rand() % 8 + 5;
int i = 0;
for (; i < len; ++i){
str[i] = (rand() % 2 ? 'a' : 'a') + (rand() % 26);
}
str[i] = '\0';
return str;
}

int main(void)
{
char * p[SIZE];
randomize();

for (int i = 0; i < SIZE; ++i){
p[i] = get_random_psw(); //buradan sonra puts(p) ile ekrana bassaydık bu problem çzülürdü (farklı passwordler yazardı)
}
 
for (int i = 0; i < SIZE; ++i){
printf("%s\n", p[i]);
}
}

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

//dinamik ömürlü nesne adresi döndürsün

char * get_random_psw(void);
{
int len = rand() % 6 % 5;
char * pd = malloc(len + 1);
if (!pd) return NULL;

for (int i = 0; i < len; i ++){
pd[i] = (rand() % 2 ? 'a' : 'a') + (rand() % 26);
}
pd[len] = '\0';
return pd;
}

int main(void)
{
char * p;
randomize();

for (int i = 0; i < SIZE; ++i){
p[i] = get_random_psw();
puts(p[i]);
free(p);
}
}
return 0;
}


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

int main(void){
int n;

printf("KAC TANE: ");
scanf("%d", &n); // ==> 0)

int  * pd = (int*)malloc(n * sizeof(int));
free(pd);
}

!! free fonksiyonuna gönderilen argümanını NULL pointer olması 
bir tanımsız davranış değildir. bu durum no-operation(faydasıda yok zararıda)

int main(void){
int n;

printf("KAC TANE: ");
scanf("%d", &n); // ==> 0)

//implementation defined

int  * pd = (int*)malloc(n * sizeof(int));
if (pd == NULL)
printf("malloc(0) cagrisi NULL ptr dondurdu\n");
else
printf("malloc(0) cagrisi % p adresini dondurdu\n",pd);

free(pd);
}

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

!! malloc işlevini dinamik bir pointer dizisi oluşturmak amaçlı da kullanabiliriz

int main(void)
{
int n;

int ** pd = (int**)malloc(n * sizeof(int*)); 
for (int i = 0; i < n; ++i){
pd[i]
}
}

----------

matrisi implemente etmenin 3 yolu:

//satir ve sütun sayısı programın çalışma zamanında belli olan 
bir matris oluşturun ve bu matrisi rastgele değerler ile doldurup
ekrana  yazdırın 

int main(void)
{
size_t row_size, col_size;

printf("olusturulacak matrisin satir ve sutun sayisini giriniz: ");
scanf("%zu%zu", &row_size, &col_size);

int ** pd= (int **)malloc(row_size * sizeof(int*));
if (!pd){
fprintf(stderr,"bellek yetersiz\n");
return 1;
}

for (size_t i = 0; i < row_size; ++i){
pd[i] = (int *)malloc(col_size * sizeof(int));
if (!pd[i]) {
fprintf(stderr, "bellek yetersiz\n");
return 1;
}
}

randomize();

//fill matrix with values
for (size_t i = 0; i < row_size; ++i){
for (size_t k = 0; k < col_size; ++k){
pd[i][k] = rand() % 10;
}

for (size_t i = 0; i < row_size; ++i){
for (size_t k = 0; k < col_size; ++k){
printf("%d", pd[i][k]);
}
printf("\n");
}
}
for (size_t i = 0; i < row_size; ++i){
free(pd[i]; //int dizileri free etmek için
}
free(pd); //pointer diziyi free etmek için
}

//bu şekilde sözde 2 boyutlu dizi oluşturulur, matrisin biri bir yerde diğeri heap alanında bir yerde olur

--------------------------
// alternatşf bir implementasyon


int main(void){
size_t row_size, col_size;

printf("olusutulucak matrisisn satir ve sutun sayisni giriniz: ");
scanf("%zu%zu", &row_size,&col_size);

int * pd = (int*)malloc(row_size * col_size * sizeof(int));
if (!pd){
fprintf(stderr,"bellek yetersiz\n");
return 1;
}
randomize();

for (size_t i = 0; i < row_size; ++i){
for (size_t k = 0; i < col_size; ++k){
pd[i * col_size + k] = rand() % 10;
}
}

for (size_t i = 0; i < row_size; ++i){
for (size_t k = 0; i < col_size; ++k){
printf("%d",pd[i * col_size + k];
}
printf("\n");
}

// bu kod ile daha az bellek alanı kullandık (avanataj)
// row * col * sizeof(int) //contigious (sıralı) bir bellek alanına ihtiyaç vardır (dezavanataj)
//kod tarafında double deref. olamıyor (dezavanataj)

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

int main(void){
size_t row_size, col_size;

printf("olusutulucak matrisisn satir ve sutun sayisni giriniz: ");
scanf("%zu%zu", &row_size,&col_size);

int * pd = (int*)malloc(row_size * col_size * sizeof(int));
if (!pd){
fprintf(stderr,"bellek yetersiz\n");
return 1;
}
randomize();
int ** ptr = (int**)mallox(row_size * sizeof(int*));

for (size_t i = 0; i < row_size; ++i){
ptr[i] = pd + (i * sizeof(int));
}

for (size_t i = 0; i < row_size; ++i){
for (size_t k = 0; i < col_size; ++k){
ptr[i][k] = rand() % 10;
}
}

for (size_t i = 0; i < row_size; ++i){
for (size_t k = 0; i < col_size; ++k){
printf("%d",ptr[i][k];
}
printf("\n");
}
free(pd);
free(ptr);

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

void * realloc(void * vp, size_t new_size)

1. paramtereye malloc veya calloctan alınmış paramtre alınır
2. paramtereye yeni boyut geçilir 

!! realloc sadece dinamik olarak ayrılmış alanlar üzerinde büyütme veya küçültme yapabilir

int main(void){
size_t n;

printf("kac elemanli dizi istiyorsunuz: ");
scanf("%zu", n);
int * pd = (int*)malloc(n * sizeof(int));
if (!pd){
fprintf(stderr,"bellek yetersiz\n");
return 1;
}

printf("malloc ile elde edinilen bellek blogu adresi : %p\n", pd);

randomize();
set_array_random(pd,n);
printf_array(pd, n);

printf("kac eleman daha ekleyelim: ");
size_t n_plus;
scanf("%zu", &n_plus);
pd = (int *)realloc(pd, (n + n_plus * sizeof(int));
if (!pd){
fprintf(stderr, "bellek yetersiz\n");
return 1;
}
printf("realloc ile elde edinilen bellek blogu adresi : %p\n", pd);
set_array_random(pd + n, n_plus);
print_array(pd, n + n_plus);

free(pd);
}

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

!! reallocation takes time //zırt pırt çağırma :)
!! reallocation invalidates pointer 

!! realloc(NULL, n) ile malloc(n) arasınd fark yok
//döngü dışında malloc çağırılıcak döngü içinde calloc cağırılacak

int main(void)
{
//döngüsel bir yapı içinde bir dinamik diziyi sürekli 1 eleman büyütmek
int ch;
int ival;

randomize();
int * pd = NULL;
int size = 0;
for (;;){
printf("tam sayi girecek misiniz: (e) (h)");
while ((ch = _getch()) != 'e' && ch != 'h')
;
printf("%c\n", ch);
if (ch == 'h')
break;
printf("tam sayiyi girin: ");
ival = rand() % 1000;
printf("%d\n",ival);
pd = (int*)realloc(pd, (size + 1) * sizeof(int));
if (!pd){
printf("bellek elde edilemeiyor\n");
return 1;
}
pd[size++] = ival;
print_array(pd, size);
_getch();
}

if (size == 0){
printf("hic giris yapilmadi\n");
}
else {
print_array(pd, size);
}
free(pd);
}

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

dinamik dizi (dynamic array) veri yapısının (data structure) :

!! cpp'da karşılığı vektörlerdir.

!! üretimde en çok kullanılan yapıdır, DİKKATLİ ÇALIŞ

- continious'dur.
- dinamik olarak veri miktarı değişebilir.

avantajları : 
1- n tane öğeden birine erişme maaliyeti constant time (dizilerde olduğu gibi)
2- sondan eklemeli maaliyeti constant time  (baştan veya ortadan constant time olmaz)

The size of a dynamic array
The capacity of a dynamic array

!! kapasite size'dan büyük tutulur. 
eğer size değeri sürekli artıyor ve kapasiteye eşit olursa diğer arttırma işleminde realloc devereye girer ve kapasiteyi arttırır 
bu sayede size kapasiteyi geçmemiş olur. bu karmaşıklığa 'amortised constant time' denir

amortised constant time  : realloc'un maaliyetinnin görmezden gelinmesine denir



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

strorage class specifier:

              auto (çok kullanılmıyor)
              register (çok kullanılmıyor)
extern
static

_Thread_local

type qualifers

const
volatile
restrict

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

auto : 

--------
register : 

int main(void)
{
register int x = 10; //derleyici sen de uygun görürsen x'i register'da tut. derleyici bunu yapmak zorunda değil
}

!! statik anahtarlılar register ile kullanılamaz

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

 
static :

void foo(void)
{
int x = 10;
static int y = 10;

printf("x = %d y = %d\n", x, y); //x hep 10 yazar, y'nin değeri sürekli artar
x += 2;
y += 2;
}

int main(void)
{
for (int i = 0; i < 10; ++i){
foo();
}
}

----------

void foo(void)
{
static char str[1000] = "ziya";

puts(str);
strcat(str, "can");
}

int main(void)
{
for (int i = 0; i < 10; ++i){
foo(); //ziya, ziyacan, ziyacancan, ziyacancancan ...
}
}

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

!! C ve C++' gelişmek için bol bol kod okunmalı ve geliştikçe kodları review yap

static yerel değişkenler neden kullanılır :
-  adres döndürmek için  

!! asla otomatik ömürlü değişkenin adresinin döndürme
!! adres döndüren bir fonksiyonun geri dönüş değerinin neyin adresi olduğunu dökümante et (çok önemli)

-----
bir fonksiyon adres döndürüyorsa:
-statik ömürlü nesne adresi dönecek
-dinamik ömürlü nesne adresi dönecek
-çağırandan aldığı adresi döndürecek

-----
geri dönüşü anlamak için bunu uygula : //aynı adres çıkıyor ise static ömürlü farklı adres çıkıyor ise dinamik ömürlü

char * func(void);

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

printf("%p\n", str);

for (int i = 0; i < 10; ++i){
printf("%p\n", func());
}
}

------

int main(void)
{
time_t timer = time(NULL);

const char* p1 = ctime(&timer);
(void)(gets);
const char* p2 = ctime(&timer);
(void)(gets);
const char* p3 = ctime(&timer);
(void)(gets);

puts(p1); //hep aynı adres yazar static adres döndürmediği için, tekrar tekrar bellekte oluşşturulacak
puts(p2);
puts(p3);
}

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


char * get_psw(void)
{
static char buffer[100]; //static yerel değişken sayesinde tekrar tekrar oluşturulmaz üstüne yazar

int len = rand() % 7 + 5;

for (int i = 0; i < len; ++i){
buffer[i] = rand() & 26 + 'A';
}
buffer[len] = '\0';
return buffer;
}

int main(void)
{
char * p[10];

randomize();
for (int i = 0; i < 10; ++i){
p[i] = ge_psw()
}
}

-------

void func(void)
{
int call_count = 0; //burası static olmalı

printf("beni %d. kex cagirdilar\n", ++call_count);
}

int main(void)
{
for (int i = 0; i < 10; ++i)
{
func(); //sürekli aynı sayı yazar çünkü her seferinde tekrar hayat gelecektir 
}
}


-------

void func(void)
{
static int call_count = 0;

printf("beni %d. kex cagirdilar\n", ++call_count);
}

int main(void)
{
for (int i = 0; i < 10; ++i)
{
func(); // static yapılınca düzelir
}
}

-------

void func(void)
{
static bool first_call_flag = true; //static'i kaldırarak dene

if (first_call_flag){
printf("rastgele sayilar\n===========\n");
first_call_flag = false;
}
printf("%d\n",rand());
}

int main(void)
{
randomize();

for (int i = 0; i < 10; ++i){
func();
}
}

------
!! otomatik ömürlü değişkenler her çağrıldığında stack'de tekrar oluşturulur

int get_xyx_value(int n)
{
static const int primes[] ={ //böyle bir diziyi static yap otomatik olması maaliyetli
2,3,54,21,2,4,12,4,4,3
1,4,2,5,21,2,4,12,21,2,
2,3,54,21,2,4,12,4,4,3
1,4,2,5,21,2,4,12,21,2,
};

return primes[n];
}

-----------

linkage kavramı : farklı dosyalarda fonksiyon veya değişken kullanıldığında onun
aynı varlığa mı ilişkin yoksa farklı varlığa mı ilişkin olduğunu söyler

- external linkage (dış bağlantı) : başka modüller tarafından da kullanılabilinir, linker aynı varlık olarak görür
- internal linkage (iç bağlantı) : sadece bu modül kullanabilir, linker farklı varlık olarak görür
- no linkage (bağlantısız)


         hasan.c                    omer.c    
      |          |               |         |
      |     x    |               |    x    |
      |          |               |         |
      |          |               |         | 
      |          |               |         |         
                                    

external linkage olursa hasan.c dosyası içindeki x değişkenini omer.c kullanabilir
internal linkage olursa hasan.c dosyası içindekli x değişkenini omer.c kullanamz

!! fonksiyonlar için ve global değişkenler varsa default external olur

!! dış bağlantıya açılmış aynı isimde 2 varlık açılamaz 
!! global olarak tanımlamak onları dış bağlantıya sokar
!! extern anahtar sözcüğünün fonksiyon isminde olması veya olmaması arasında fark yok
!! değişkenin external yazılması ile yazılmaması arasında fark vardır

!!!! eğer dışarı açılacak ise kaynak dosyada tanımı yapılır, başlık dosyasında extern bildirimi yapılır.
!!!! static double dval = 2.3 //aynı dosya içinde farklı fonksiyonlarda kullanılabilinir
!!!! int g = 10 (extern yapılmış başlık dosyasında) farklı dosyalarda kullanılabilinir

global değişkenini dışa açmak istiyor musun ?
evet

//bugra.c
int ival = 1
//bugra.h
extern int gval;

fonksiyonu dışa açmak istiyor musun ?
evet

//bugra.c
int foo(int x)
{
return x * x;
}

//bugra.h
extern int foo(int x);
int foo(int x); //default extern gelir

global değişkenini dışa açmak istiyor musun ?
hayır
//bugra.c
static int ival = 1

fonksiyonu dışa açmak istiyor musun ?
hayır
//bugra.c
static int bar(int x)
{

}

!!extern bildiriminde dizi boyutunu yazmaya gerek yok

global namespace pollution problem : isimlerin çakışmasıdır c++ da namespace ile bu çözülür

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

omer.c

int g = 10;
static double dvaL = 2.3;

void ofunc(void)
{

}

!! g değişkeni dışarı açılabilir
!! dval sadece o kaynak dosyayı ilgilendirir, dışarı açılamaz

---------------------
c kaynak dosyasına verilen adlar:
source file
implementation file
dat si
.c
code file
------------------------
source file : ön işlemci komutları dahil
translation unit : ön işlemci programların işini bitirmiş hali
-----------------------