29. Hafta

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

int get_max(int n, ...)
{
va_list args;
va_start(args, n);
int max;

for (int i = 0; i < n; ++i) {
int ival = va_args(args, int);
if (i == 0)
max = ival;
else if (ival > max)
max = ival
}

va_end(args);
return max;
}

int main(void)
{
int x = 10;
int y = 20;
int z = 15;

printf("max = %d\n", get_max(3, x, y,z));
}


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


void myprintf(const char* p, ...)
{
va_list args;
va_start(args, p);

while (*p) {
int c = toupper(*p);

if (c == 'I') {
printf("%d\n", va_args(args, int));
}
else if (c == 'U') {
printf("%u\n", va_args(args,unsigned int));
}
else if (c == 'L') {
printf("%ld\n", va_args(args, long));
}
if (c == 'S') {
printf("%d\n", va_args(args, const char *));
}
else if (c == 'F') {
printf("%f\n", va_args(args, double));
}
++p;
}

va_edn(args);
}


int main(void)
{
int x = 10;
unsigned int y = 3u;
long lval = 5;
char str[] = "murat";
double dval = 4.45;

myprintf("iULsF", x, y, lval, str, dval);
}


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

char * strapp(const char* p, ...)
{
va_list arglist;
va_list args;

va_start(arglist, p);
va_copy(args, arglist);

size_t len = strlen(p) + 1;

const char *pstr;
while ((pstr = va_args(arglist, const char*)) != NULL) {
len += strlen(pstr);
}

va_end(arglist);
char *pd = (char *) malloc(len + 1);
if (!pd) 
return NULL;

strcpy(pd , p);
while ((pstr = va_args(arglist, const char*)) != NULL) {
strcat(pd ,pstr);
}
va_end(args);

return pd;


int main(void)
{
char s1[] = "cinar";
char s2[] = " gursay";

char *pd = strapp(s1, s2, " volkan ", " gundogdu", NULL);
printf(" (%s)\n", pd);

free(pd);
}

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

void func(const char* p, ...)
{
char buffer[1000];

va_list args;
va_start(args, p);
vsprintf(buffer, p, args);
}

int main()
{
int x = 10;
int y = 20;
double dval = 4.5;

func("%d %d %f\n", x, y, dval);
}

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

compound literals (bileşik sabit)
----------------------------------

c99 ile dile eklendi c++ 'da yok


int main()
{
(int){14} //değeri 14 olan int değişkeni

}



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

//adreste verebiliriz

void func(const char int* ptr)
{
printf("*ptr = %d\n", *ptr);
}

int main()
{
func(&int) {14});
}

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

void func(const char int* ptr)
{
while (size--)
printf("%d "i *ptr++);
printf("\n");
}


int main()
{
func((int[]) {2, 5, 7, 123}, 4);
}

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

int main(void)
{
int* p = (int[]{2,5,7,123};

p[0] = 45;
p[3] = 7;

for (int i = 0; i < 4; ++i) {
printf("%d ", p[i]);
}
}

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

int main(void)
{
Date mydate;

mydate = (Date){3,11,2022};

}

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

int main(void)
{
struct tm* tp = localtime(&(time_t) {time(0)});

printf("%02d:%02d:%02d", tp->tm_hour, tp->tm_m,n, tp->sec);

printf_array((int[10]) {[5] = 5, [7] = 7, [9] = 9}, 10);
}

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

struct Data {
int a, b, c;
double dx, dy;
char str[20];
};

int main(void)
{
(struct Data) {.b = 12, .dx = 4.5, .str = "mustafa"}
}

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

int main(void)
{
int a[5] = {2,4,6,3,7};


}

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

VLA (variable lenght array)
-----------------------------

c99 ile dile eklendi ancak c11 ile de kulancıc tercihine bırakıldı kullanılması

#idfed __STDC_NO_VLA__

#endif


dinamik bellek olayına girmeden bellekte yer ayırabiliriz

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

void func(int x)
{
int a[x];

for (int i = 0; i < x; ++i)
a[i] = rand() % 10;
//code
for (int i = 0; i < x; ++i)
printf("%d", a[i]);
printf("\n");
}

int main()
{
srand((unsigned)(time(NULL)));

for (int i = 5; i < 20; ++i) {
func(i);
}
}

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

bir dizinin medyanını bulmaya çalışmak

int icmp(const void* vp1, const void* vp2)
{
return if *(*const int*)vp1 > *(const int*)vp1 ? 1:
*(const int*)vp1 < *(const int*)vp1 ? -1 : 0
}

double get_median(const int* p, size_t size)
{
int a[size];
memcpy(a, p, size * sizeof(int));
qsort(a, size, sizeof(*a), &icmp);
return p[size / 2];
}

int main()
{
int a[10] = {2,6,-4,3,7,9,1,4,81,-45};


}


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

int main(void)
{
int row, col;

printf("matrisin satir ve sutun sayisini girin: ");
scanf("%d%d", &row, &col);

int* pd = malloc(row * col * sizeof(int)) //bu şeklilde yaparsak köşeli parantez operatörünün operaqndı yapamam
int (*pd)[row][col] = malloc(sizeof(*pd)) // bu şekilde yapılabilir

}

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

int main(void)
{
int row, col;

printf("matrisin satir ve sutun sayisini girin: ");
scanf("%d%d", &row, &col);

int a[5][10];
int(*p)[5][10] = &a;

//*p == a DEMEK
}

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

//yukarıdakini boyutu compile time'da değilde run time'da belli olan dizi içn yapıyoruz

int main(void)
{
int row, col;

printf("matrisin satir ve sutun sayisini girin: ");
scanf("%d%d", &row, &col);

int (*p)[row][col] = malloc(sizeof(*p));

for (int i = 0; i < row; ++i) {
for (int k = 0İ k < col; ++k) {
(*p)[i][k] = rand() % 10;
}
}

for (int i = 0; i < row; ++i) {
for (int k = 0; k < col; ++k) {
printf("%d", (*p);
}
putchat('\n');
}
free(p);
}

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

static assert ve assert makrosu
-------------------------------

programlama hataları nasıl bulunru?

- koda ekk kodlar yaılabilir kodlama hatalarını tespit etmek için

void func(int x)
{
if (x < 0 || x > 9) {
printf(......);
abort();
}
}

---------------
//static assertions : programın çalışma zamanından bağımsız, derleme zamanında yaplan doğrulamalar
//dynamic assertions : programın çalışma zamanına yönelik doğrulamalar
--------------


//mesela aşağıda null pointer gelmemesi gerekiyor


void func(int *ptr)(
{
if (ptr == NULL) {
//..... hatayı anlatan  bir kod
abort
}
}

-------------------
// bu kodlar compile time'da derleyiceye hata mesajı verir

static assert yokken başka yönemler kullanılırdı

int main(void)
{
int a[sizeof(int) == 2]; //bu şekilde bir hile kullanılabilir

}

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

typedef int a[sizeof(int) > 4];

int main(void)
{
{typedef int a[sizeof(int) > 4];}
}


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

union Data {
int x : constant expression;

};

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

artık böyle hilelere gerek yok c11 ile static assert fonksiyonu sayesinde

_Static_assert(sizeof(long) > sizeof(int), "int turunun sizeof degeri yetersiz");

!! static assert bir keyworddür

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

kontroller run time ve compile time kontrolü olarak 2'ye ayrılıur,

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

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

}

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

run time 'da bunları yapmanın birçok dezaantajı vardır
 - kullanıcıyı yanıltabilir
 - yeni relase'ler geldiğinde karışıklık çaıkabilir

bunların yerine bu karışıklıkları ortadan kaldıran aşağıdaki yapı kullanılabilir

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

assert makrosu

#incude <assert.h>

void  func(int *p)
{
//parantexz içine sadece doğru olan kod yazılır
assert(p != NULL) //assert sözcüğünden bunun hatayı bulmaya yarayan kod olduğunu anlayacak
}

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

void  func(int *p)
{
assert(p != NULL);
}

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

func(p);
}