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();
}

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 impremente 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
--------------------------

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
// row * col * sizeof(int)
//satırlar bellekte ardışık
//kod tarafında double deref. olamıyor

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

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, 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;
}
randomize();
set_array_random();
printf_array(pd, n);

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

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

!! 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) :

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

avantajları : 
1- n tane öğeden birine erişme maaliyeti constant time
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

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

!! function overloading: aynı isimde farklı fonksiyonlara 

auto :

--------
register : 

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

!! 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 :
char * func(void);

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

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

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

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)
{
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 başka bir varlık olarak görür
internal linkage (iç bağlantı) : sadece bu modül kullanabilir, linker aynı varlık olarak görür
no linkage (bağlantısız)

!! 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);

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: 

---------------------
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
-----------------------