26. hafta

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

x << 4 >> 8 //x'i 4 sola kaydır 8 sağa kaydır

-----------
//düşük anlam bitlerinden yüksek anlam bitlerine geçiş olacak

//DE AB
//FC 12
//12 FC
//AB DE

int main(void)
{
//1 byte 8 bit
//2 byte 16 bit
//4 byte 32 bit

unsigned int x = 0xAB12FCDE;

printf("%x\n" ,x);
printf("%x\n" ,(x << 24) || (x >> 24) | (x >> 8 & 0x0000FF00) | (x << 8 & 0x00FF0000));

}

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

int main(void)
{
int x = 10;

x = -~x
printf("x = %d", x);
}

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

----------------
#define HIDDEN 1 //sayının 1. biti
#define SYSTEM 2 //sayının 2. biti
#define READONLY 4 //sayının 3. biti
#define ARCHIVE 8 //sayının 4. biti
#define WRİTE 16 //sayının 5. biti

struct FileProp {
char name[20];
unsigned int size;
//...
unsigned int fileflags;
};

struct FileProp* get_file_prop(void);

int main(void)
{
struct FileProp* p = get_file_prop();

if (p->fileflags & READONLY) { //2. biti 1 mi

}

p->fileflags &= ~(HIDDEN | ARCHIVE);

(

}
---------------

neden bir tam sayının bitlerini boolean olarak kullanayım

bit vector kavramı

-daha az storage için
-daha hızlı işlemler için
-fonksiyon parametre değişkeni sayısını azaltmak

bit vector kullanımına tipik bir örnek: 

ctype kütüphanesi

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

myctype.h

#define UPPER 1
#define LOWER 2
#define DIGIT 4
#define XDIGIT 8
#define PUNCT 16
#define SPACE 32
#define PRINT 64

extern const int ct_[];

#define ISUPPER(c) (ct_[c] & UPPER)
#define ISLOWER(c) (ct_[c] & LOWER)
#define ISALPHA(c) (ct_[c] & (LOWER | UPPER))
#define ISDIGIT(c) (ct_[c] & DIGIT)
#define ISALNUM(c) (ct_[c] & (LOWER | UPPER | DIGIT))
#define ISPUNCT(c) (ct_[c] & (PUNCT)
#define ISSPACE(c) (ct_[c] & (SPACE)
#define ISXDIGIT(c) (ct_[c] & (XDIGIT)
#define ISPRINT(c) (ct_[c] & (PRINT)

int main()
{
int ch;

printf("bir karakter girin: ");
ch = getchar();

if(ISUPPER(ch)) {
printf("ever buyuk harf degil");
}else {
printf("hayir buyuk harf degil");
}
}

// main.c

int main(void)
{
for (int i = 0; i < 128; ++) {
int flags = 0;
if (isupper(i)) flags |= UPPER;
if (islower(i)) flags |= LOWER;
if (isdigit(i)) flags |= DIGIT;
if (isxdigit(i)) flags |= XDIGIT;
if (ispunct(i)) flags |= PUNCT;
if (isspace(i)) flags |= SPACE;
if (isprint(i)) flags |= PRINT;
if (i && % 16 == 0)
printf("\n");
printf("%2d ", flags);
}
}

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

Bir tam sayının belirli bit alanlarını ayrı değişkenler olarak kullanmak

// 00000000 00000000 00000000 00000000

-------------------------------------------
yapılarım bit alanı (bitfields) elemanları:
-------------------------------------------

Dizinin bazı elemanları bit alanı bazı elemanları bit alanı olmayabilir

int n = 3;

struct Data {
int x; //bit alanı değil
int y : 5; //bit alanı 5 bitlik alanda tutulacak
int y : n ; //hata
};

-------
!! hepsi bit alanı olmak zorunda değil

struct Data {
int x;
int y : 10;
struct {
int a : 3; //3 bitlik alanda tutulur
int b : 3;
int c : 2;
};
};

------

struct Data {
long a : 3; //saçma
//int kullan
};

------

struct Data {
int x : 3;
int y : 5;
int z : 2;
int t : 6;
};

------
//haftanın günlerini tutmayı aşağıdaki gbi gösterebiliriz

struct Data {
unsigned int wd : 3;
};

------
typedef struct {
int x : 3;
int x : 3;
int x : 3;
}Data;

int main(void)
{
Data mydata;

mydata.x = 3;
mydata.y = 12;
mydata.z = 24;

Data* p = &mydata; //elimizde pointer var ise

p->y = 5;
}

-----

!! yapıların bit alanı elemanlarının adres operatörünün
operandı olması sentax hatası oluşturur

typedef struct {
int x : 3;
int x : 3;
int x : 3;
}Data;

int main()
{
Data dt = {2, 6, 23};
&dt.y; //hata 2
}

----------
!! birçok c programcısı designated init. sentaksını bilmediği için kullanmıyor 

typedef struct {
int x : 3;
int y : 5;
int z : 1;
}Data;

int main(void)
{
Data dt = {
.y = 4,
.x = 4,
.z = 4,
};
}

------
//kapasitesi

typedef struct {
int x1 : 3;
int x2 : 1;
int x3 : 8;
int x4 : 2;
int x5 : 9;
}Data;

int main(void)
{
printf("sizeof(Data) = %zu\n", sizeof(Data));
}  

------------
//8 bitte başka bir şey kullanmamak için padding bit kullanılabilir

struct Nec {
int x : 5;
int : 3; //padding bit
int y : 4;
};

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

unionların 2 kullanım fikri var

1- bellek alanı, tek bellekte kullanılır

2- bir verii farklı 2 şekilde temsil etmek

--------

// bir datetime verisini
//iki  ayrı şekilde temsil etmek istiyoruz

//birinci temsil : doğrudan insanın anladığı form
gun ay yıl saat dakika saniye
işaretsiz bir tam sayı olarak
tarihsaat ==> tam sayı
tam sayı ==> tarih saat

-----

typedef union{
struct {
int mday : 5;
int mon : 4;
int year : 7; // + 1980
int hput : 5; // 0 - 23
int min : 6; //0 - 23 
int sec : 5; // * 2
};
uint32_t uval;
}DateTime;

int main(void)
{
DateTime dx = {
.mday = 24,
.mon = 12,
.year = 2013 - 1980,
.hour = 14,
.min =56,
.sec = 28 / 2 
};
printf("24 12 2013 14 56 28 için tam sai degeri %u\n", dx.uval);
}
S
--------------------------

!!!! güzel bir yapı bitler için

typedef union {
struct {
unsigned int bit0 : 1;
unsigned int bit1 : 1;
unsigned int bit2 : 1;
unsigned int bit3 : 1;
unsigned int bit4 : 1;
unsigned int bit5 : 1;
unsigned int bit6 : 1;
unsigned int bit7 : 1;
unsigned int bit8 : 1;
};
uint32_t uval;
}Bits;

int main()
{
printf("sizeof(Bits) = %zu\n", sizeof(Bits));

Bits x  = { .uval = 0};

x.bit5 = 1;
printf("uval %u\n", x.uval);
}

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

struct Data {
int a : 4;
int b : 3;
int c : 6;
int not_used : 2; //burayı şimdilik kullanma demek
};

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

union Data {
int x;
struct {
short a;
short b;
};
};

union Data {
long x;
int i;
char str[4];
};


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

farklı adres türlerine yönelik güvenli dönüşümler :

1- bir nesne adresinin char dizi adresi olarak kullanılması

2- Bir yapı nesnesinin kendi adresi ile ilk elemanının adresi arasındaki dönüşümler


int main(void)
{
double dval = 36.893455;

unsigned char* p = (unsigned char*)&dval;

for (size_t i = 0; i < sizeof(dval); ++i) {
printf("%u\n", p[i]);
}
}

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

bu derste görülen konular :

- komut satırı argümanları

- dosya işlemleri


bit alanı aşağıdaki türleri alabilir

struct Nec {
_Bool x : 1;
int y : 4;
signed int : 4;
usigned int : 3;
};

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

struct Nec {
_Bool x : 5;
int : 3; //2 byte yayılmaması için bu şekilde padding bit kullanılabilir
};

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

komut satırı argümanları (command line arguments) 
-------------------------------------------------

komut satırı : işletim sisteminin kullanıcısı ile oluşturduğu arayüz

dir *.txt 
    ------
    burası komut satırı kısmıdıır

bir yazı C'de bir fonksiyona nasıl iletilir ?

char *
const char *

birden fazla yazı olsa ?

yazıların adresleri bir pointer dizisinde tutulsun
fonksiyona pointer dizisinin adresi gönderilsin


--------
//       char * [] //aynı anlamda
void foo(char** ptr, int size)
{
for (int i = 0; i < size; ++i) {
printf("%s", ptr[i]);
}
}

int main(void)
{
char* p[] = {"ali", "mehmet", "hasan", "deniz"};

foo(p, 4);
}

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

komut satırından argümanları alarak bu argümanlara erişecek bir programın
main fonksiyonu
tipik olarak 
2 tane parametre değişkenine sahip olur

int main(int argc, char **argv)
{

}

// argc : komut satırındaki argüman sayısı
// argv : komut saatırındaki yazıları tutan pointerın adresi

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

int main(int argc, char **argv)
{
printf("argc = %d", argc);
}

//komut satırında 
//C:\bugra>a
//yazarsak
//argc = 1 çıkar

//komut satırında 
//C:\bugra>ali veli hasam
//yazarsak
//argc = 3 çıkar

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

int main(int argc, char **argv)
{
printf("argc = %d", argc);

for (int i = 0; i < argc; ++i) {
printf("argv[%d] = %s\n", i , argv[i]);
}
}

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

int main()
{
if (argc != 3){
printf("kullanim: <kopyala> <kaynak dosya ismi> <hedef dosya ismi>\n");
return 1;
}

printf("%s dosyasinin %s isimli koyasi olusturuldu\n", argv[1], argv[2]);
}

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

komut satırından çalışan basit bir hesap makinesi yapıyoruz

hes 12 * 45
540

hes 45 + 35
75

int main(int arg, char**argv)
{
if (arg != 4) {
printf("usage: <calc> <op1> <operator+-*/> <op2>\n");
return 1;
}

int op1 = atoi(argv[1]);
int op2 = atoi(argv[3]);

switch (*argv[2]) {
case '+' : printf("%d\n", op1 + op2); break;
case '-' : printf("%d\n", op1 - op2); break;
case '*' : printf("%d\n", op1 * op2); break;
case '/':
if (op2 == 0)
printf("sifira bolme hatasi\n");
else
printf("%f\n", (double)op1 / op2);
}
}

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

yazıyı ters çeviren algoritma

char* Strrev(char* p)
{
size_t len = strlen(p);

for (int i = 0; i < len / 2; ++i)
{
char temp = p[i];
p[i] = p[len - 1 - i];
p[len - 1 - i} = tem
}
return p;
}

int main(int argc, char**argv)
{
for (int i = argc - 1; i >= 1; --i) {
printf("%s", Strrev(argv[i]));
}
}

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

int main(int argc, char**argv)
{
if( argv[argc] == NULL) {
printf("argv[%d] Null pointer\n", argc);
}

int i = 0;
while (argv[i]) {
puts(argv[i++]);
}
}

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

int main(int argc, char**argv)
{
char source_file_name[80];
char dest_file_name[80];

if (arg != 3) {
printf("kaynak dosya ismi: ");
scanf("%s", source_file_name);
printf("hedef dosya ismi: ");
scanf("%s", dest_file_name);
} else {
strcpy(source_file_name, argv[1]);
strcpy(dest_file_name, argv[2]);
}

printf("%s doysasının %s isimli kopyası olusturuldu", source_file_name, dest_file_name)
}


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

Dosya işlemleri

#include <stdio.h>

printf
scanf
sprintf
snprintf
sscanf
putchar
getchar

handle yapısı / tekniği kullanılır

FILE* fopen
foo(FILE*)
bar(FILE*)
fclose(FILE*)

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

fopen : dosya açan fonksiyon
 dosya açmak demek o dosya üzerinde işle yapabilmeye denir

dosyları belli modlar ile açabailiriz

dosya açış modları
-----------------

açış modu,

açılmak istene (üstünde işlem yapılacak dosya) varsa ne olacak yoksa ne olacak
dosya üzeirnde hangi işlemleri yapabilirim
    dosyadan okuma yapmak
    dosyaya yazma işlemi yapmak (write)
    dosyanın byte'larını değiştirmek (bu da yazmadır)


--------------
!! standart kütüphane kullanarak dosyayı açmadan hangi işlemleri yapabiliriz
- dosyayı silmek (remove)
- dosyanın ismini değiştirmek (rename)

!! yazma modunda dosya yazmak dosya oluşturmak anlamında hgelir


dosya okuma modunda açma (read) : dosya var ise açılır yoksa açılmaz
                                  dosyandan okumaya izin verilir, yazma işlemi yapılamaz

dosya okuma modunda açma (read +) : dosya var ise açılır yoksa açılmaz
                                  dosyandan okumaya izin verilir, yazma işlemi yapılır


dosya yazma modunda açma (write): dosya var ise dosya kaybedilir, 

dosya yazma modunda açma (write +): dosya var ise dosya kaybedilir, okuma işlemi de yapılabilir

dosya sona ekleme modunda açılabilir (yazma) (append) : dosya varsa açılır dosya yoksa oluşturulur
                                                        var olan bytlar değişmez

dosya sona ekleme+ modunda açılabilir (sona yazma) (append) : dosya varsa açılır dosya yoksa oluşturulur
                                                             var olan bytlar değişmez, dosyadan okuma yapılabilir

dosya ya text modunda açılır, ya da binary modda açılır


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

FILE* fopen(const char* pfilename, const char* pmode); //dosya ismi , dosya açış bilgisi

"r" => okuma
"w" => yazma
"a" => sona ekleme

"r+" => okuma+
"w+" => yazma+
"a+" => sona ekleme+

!! yukarıdakikerin hepsi text modundadır
!! aşağısı binary modda açar

"rb" => okuma
"wb" => yazma
"ab" => sona ekleme

"rb+" => okuma+ //r + b geçerli
"wb+" => yazma+ //w + b geçerli
"ab+" => sona ekleme+ //a + b geçerli

malloc gibi null pointer mı kontrol edilmelidir

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

//kemal.txt dosyasını okuma (text) modunda açınız
//dosya acılmaz ise standart hata akımına bir bilgilendirme yazısı vererek programı sonlandır

int main(void)
{
FILE* f = fopen("kemal.txt", "r")

if (!f) {
fprintf(stderr, "kemal.txt dosyasi acilamadi\n");
return 1;
}
}

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

//kemal.txt dosyasını yazma (text) modunda açınız
//dosya acılmaz ise standart hata akımına bir bilgilendirme yazısı vererek programı sonlandır

int main(void)
{
FILE* f = fopen("kemal.txt", "w")

if (!f) {
fprintf(stderr, "kemal.txt dosyasi acilamadi\n");
return 1;
}

printf("kemal.txt dosyasi olusturuldu\n");
}


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

flose : dosyayı kapatan fonksyion

!! dosya ile işin bitine dosyayı kapat

int fclose(FILE*);

int fcloseall(void); //bütün dosyaları kapatır, standart değildir.

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

dosyada yapılan işlemler

dosyadan okuma
dosyadan yazma

formatlı yazma : yazılan  veya okunana karakter kodları demektir
formatsız yazma : yazılan veya okunan bytlearın kendi değeridr

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

dosyadan formatsız okuma işlemi yapan 

fgetc fonksiyonu

getchar ile çok benzer, fgetc dosyadan okuma yapar

int fgetc(FILE *);

!! fgetc en tipik başarısızlık nedeni okunacak byte kalmamasıdır, -1 döndürürse başarısız

--------

#include <stdio.h>

int main(void)
{
FILE* f = fopen("murat.txt", "r");
if (!f) {
fprintf(stderr,"dosya acilamadi\n");
return 1;
}

int ch;

while (ch = fgetc(f)) != EOF) {
putchar(ch);
}
flose(f);
}

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

int main(int argc, char **argv)
{
if (argc != 2) {
fprintf(stderr, "usage: <prfile> <file name>\n");
return 1;
}
FILE* f = fopen(argv[1], "r");
if (!f) {
fprintf(stderr, "file %s cannot be opened!\n", argv[1]);
return 2;
}

int c;

while ((c = fgetc(f)) != EOF) {
putchar(c);
}
fclose(f);
}

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

dosyada kaç tane m karaketeri var onu bulan kod

int main(int argc, char **argv)
{
if (argc != 3) {
fprintf(stderr, "usage: <ksay> <file name> <character>\n");
return 1;
}
FILE* f = fopen(argv[1], "r");
if (!f) {
fprintf(stderr, "file %s cannot be opened!\n", argv[1]);
return 2;
}

int c;
int count = 0;

while ((c = fgetc(f)) != EOF) {
putchar(c == *argv[2])
++count;
}
fclose(f);
printf("%d\n", count);
}

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

int main(int argc, char **argv)
{
if (argc != 2) {
fprintf(stderr, "kullanim <asal> <dosya ismi>");
return 1;
}

FILE* f = fopen(argv[1], "r");
if (!f) {
fprintf(stderr, "%s dosyasi acilamadi\n", argv[1]);
return 2;
}

int counts[26] = {0};
int c;

while ((c = fgect(f)) != EOF) {
if (isalpha(c)) {
toupper(c)) {
++counts[toupper(c) - 'A'];
}
}

fclcose(f);

for (int i = 0; i < 26; ++i) {
if (counts[i]) {
printf("%c %d\n", 'A' + i, counts[i]);
}
}
}