14 Ekim 2008 Salı

Tek cift-kök hesaplama-toupper

/*Tek-Çift
#include

int main()
{
int sayi;
printf("Sayiyi girin:");
scanf("%d",&sayi);
if(sayi%2==1)printf("\nTek sayi");
if(sayi%2==0 && sayi!=0) printf("\nCift sayi");
}

/*kök hesaplama
#include
#include

int main()
{
double koktoplam;
int d=0,sonuc=0,j,kok[2],ax,bx,c;

printf("a katsayisini girin x^2 li terim:");
scanf("%d",&ax);
printf("\nb katsayisini girin x li terim:");
scanf("%d",&bx);
printf("\nSabit terimi girin:");
scanf("%d",&c);

for(j=-100; j<=100; j++)//kök aralığını kendin belirleyebilirsin
{
sonuc=(ax*j*j)+(bx*j)+c;
if(sonuc==0){ kok[d]=j; d++; }
}
if(d==1)//yalnızca tek kökü bulabilmişse
{
koktoplam=-(double(bx)/double(ax)); //kökler toplamını kullanarak bul
koktoplam=koktoplam-kok[0];
printf("\n\n Kokler %d %lf",kok[0],koktoplam);
}
if(d==2){
printf("\n\n Kokler %d %d",kok[0],kok[1]);
}
getch();
}

/*En büyük sayı
#include
#include
#include
#include

int main()
{
int sayi[10],x,tut=0;

randomize();

for(x=0; x<10; x++)
{
sayi[x]=random(100);
}
for(x=0; x<10; x++)
{
if(sayi[tut]>sayi[x+1])
tut=tut;
else tut=x;
}
for(x=0; x<10; x++)
{
printf("%d\n",sayi[x]);
}
printf("\n%d",sayi[tut]);
getch();
}


/*toupper
#include
#include

char cevir_beni_kamil(int key);
int main()
{
char harf;
printf("Harfi girin:");
scanf("%c",&harf);
printf("%c",cevir_beni_kamil((int)harf));
getch();
}

char cevir_beni_kamil(int key)
{
if(key>=97)
{
key=key-32;
return (char)key; //harfi buyut
}
if(key>=65 && key<97)
{
key=key+32;
return (char)key; //harfi kucult
}
}

Seri Port

#include
#include

# define data 0x378
# define status 0x379
# define control 0x37A

main(){
char kr;

printf("Başlıyor...\n");
getch();

do {

printf("\n1-Ledi Yak...\n2-Ledi söndür...\n3-Çık\n");
kr=getch();

if(kr==’1’){
clrscr();
outportb(data,11111111); //bütün girişler birlendi
printf("Led Yanıyor...\n");
getch();
}

if(kr==’2’){
clrscr();
outportb(data,0);
printf("Led Sönük...\n");
getch();
}
if(kr==’3’)
exit();
}while(1);
}

sayı-rakam

#include
#include

int main(){
FILE *f; int i=0; char buf,ilk;
f=fopen("sayi.txt","w+");
printf("Sayiyi girin:");
scanf("%d",&i);
fprintf(f,"%d",i);
fclose(f);
f=fopen("sayi.txt","r");
buf=getc(f);
while(buf!=EOF){
i++;
if(i==1)
ilk=buf;
}

if(i==7){
printf("Para %s",ilk); printf(" milyon");
}
fclose(f);
}

Öğrenci kayıt değiştirme v.s

#include
#include
#include
#include
#include

int kayit_ara(char isim[],char soyisim[]);
void kayit_degistir(char dosya[]);
void kaydet();

FILE *kayit,*goster;
int secim=0;
char dosya_adi[100],ar[100],ara[100],rx[1];;
char uzanti[]=".txt";

struct ogrenci
{
int no,telno;
char isim[100];
char soyisim[100];
}yeni_ogr;

int main()
{
printf("\n\nKayit aramak icin 1\nKayit yapmak icin 2\nCikis icin 3 girin\nEkrani Temizlemek icin 4 girin ");
scanf("%d",&secim);
if(secim==1){
gets(rx);
printf("\nOgrenci Adi:");
gets(ar);
printf("\nOgrenci Soyadi:");
gets(ara);
if(kayit_ara(ar,ara)==-1)
{
printf("\nBu isimde bir kayit bulunmamaktadir.");
main();
}
}
if(secim==2) { kaydet(); }
if(secim==3) exit(0);
if(secim==4) { clrscr(); main(); }
return 0;
}

void kaydet()
{
gets(rx);

randomize();
yeni_ogr.no=32+random(223); //öğrenci numarası belirledik
printf("\nOgrenci adi:");
gets(yeni_ogr.isim);
printf("\nOgrencinin soyadi:");
gets(yeni_ogr.soyisim);
printf("\nOgrenci telefon numarasi:");
scanf("%d",¥i_ogr.telno);

strcpy(dosya_adi,strlwr(yeni_ogr.isim));
strcat(dosya_adi,strlwr(yeni_ogr.soyisim));
strcat(dosya_adi,uzanti);
kayit=fopen(dosya_adi,"w+");

fprintf(kayit,"Ogrenci Numarasi:%d\n",yeni_ogr.no);
fprintf(kayit,"Ogrencinin Adi:%s\n",yeni_ogr.isim);
fprintf(kayit,"Ogrencinin Soyadi:%s\n",yeni_ogr.soyisim);
fprintf(kayit,"Ogrenci Telefon Numarasi:%d\n",yeni_ogr.telno);
puts("\n--------Kayit Tamamlandi.--------\n");
fclose(kayit);
main();
}

int kayit_ara(char isim[],char soyisim[])
{
char dosya[100],ch;
strlwr(isim);
strlwr(soyisim);
strcpy(dosya,isim);
strcat(dosya,soyisim);
strcat(dosya,uzanti);

if(goster=fopen(dosya,"r")){;
printf("\nKayit bulundu.\n");
ch=getc(goster);
while(ch!=EOF)
{
putchar(ch);
ch=getc(goster);
}
fclose(goster);

printf("\nDosya uzerinde degisiklik yapmak istiyor musunuz?E/H :");
ch=getch();
if(ch=='E' || ch=='e') kayit_degistir(dosya);
else main();

}
else return -1;
}

void kayit_degistir(char dosya[])
{
char command[]="del ";
strcat(command,dosya);
system(command);
dosya_adi[0]='\0';

printf("\nKayit silindi.Giris islemlerini tekrar gerceklestirmek icin Entere basin.");
gets(rx);

randomize();
yeni_ogr.no=32+random(223); //öğrenci numarası belirledik
printf("\nOgrenci adi:");
gets(yeni_ogr.isim);
printf("\nOgrencinin soyadi:");
gets(yeni_ogr.soyisim);
printf("\nOgrenci telefon numarasi:");
scanf("%d",¥i_ogr.telno);

strcpy(dosya_adi,strlwr(yeni_ogr.isim));
strcat(dosya_adi,strlwr(yeni_ogr.soyisim));
strcat(dosya_adi,uzanti);
goster=fopen(dosya_adi,"w+");

fprintf(goster,"Ogrenci Numarasi:%d\n",yeni_ogr.no);
fprintf(goster,"Ogrencinin Adi:%s\n",yeni_ogr.isim);
fprintf(goster,"Ogrencinin Soyadi:%s\n",yeni_ogr.soyisim);
fprintf(goster,"Ogrenci Telefon Numarasi:%d\n",yeni_ogr.telno);
puts("\n--------Kayit Degisikligi Tamamlandi.--------\n");
fclose(goster);
main();
}










Ogrenci vize-final

#include
#include
#include
#include
int a;
//----------------------------------------------------------------------------
void not_oku(void);
void kayit_yap(void);

int main()
{
printf("Ne yapmak istersiniz?\nNotlari okumak icin 1 girin.\nKayit yapmak icin 2 girin.\nProgrami kapatmak icin 3 girin:");scanf("%d", &a);
if(a==1)
{
not_oku();
}
if(a==3)
{
exit(0);
}
if(a==2)
{
kayit_yap();
}
return 0;
}

void not_oku(void)
{
char ch;
FILE *f;
f=fopen("C:\\notlar.txt","r");
ch=getc(f);

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

printf("\nKayit yapmak icin 2'i girin:");
scanf("%d", &a);
}

void kayit_yap(void)
{
struct ogrenci{
int vize;
int final;
char isim[25];
} ogrenci;
char buf[255];
FILE *adres; int ortalama;
adres=fopen("C:\\notlar.txt","a");

printf("Ogrenci vize notu:");
scanf("%d",&ogrenci.vize);
fprintf(adres,"Vize Notu: %d\n",ogrenci.vize);
printf("Final notunu girin:");
scanf("%d",&ogrenci.final);
fprintf(adres,"Final Notu: %d\n",ogrenci.final);
printf("Ogrenci adi:");
scanf("%s",&ogrenci.isim);
fprintf(adres,"Adi ve Soyadi: %s\n",ogrenci.isim);
ortalama=(ogrenci.vize+ogrenci.final)/2;
if(ortalama>=55)
fprintf(adres,"Durum:Gecti\n");
else
fprintf(adres,"Durum:Kaldi\n");
fprintf(adres,"**************************\n");

}

Ogrenci Kayıt

#include


int i,k,l;
int main(void){
struct ogrenci{
char adi[];
int no;
int dnotu;
};
struct ogrenci kisi[1];

for(i=0; i<1; i++){
printf("\nOgrenci adi:");
gets(kisi[i].adi);
printf("\nOgrenci numarasi:");
scanf("%d",&kisi[i].no);
printf("Ogrencinin notu:");
scanf("%d",&kisi[i].dnotu);
printf(" Kayit islemi tamamlandi. ");
}

/*İlk beş öğrenci için kayıtlar alındı.*/

printf("\nOgrenci numarasi girin:");
scanf("%d",&l);
for(i=0; i<1; i++){
if(l==kisi[i].no){
printf("\nOgrencii bulundu");
printf("\nOgrenci ders notu %d dir.",kisi[i].dnotu);
break;
}
}
}

Obeb-okek

#include
#include

int obeb(int number1, int number2);
int okek(int number1, int number2);

int main()
{
int x, y;
int n = 20;

clrscr();
while (n-- > 0) {
printf("iki tamsayı giriniz : ");
scanf("%d%d", &x, &y);
printf("obeb = %d\\n", obeb(x, y));
printf("okek = %d\\n", okek(x, y));
}
getch();
return 0;
}

int obeb(int number1, int number2)
{
int i;
int min = (number1 < number2) ? number1 : number2;

for (i = min; i >= 1; --i)
if (number1 % i == 0 && number2 % i == 0)
return i;
}

int okek(int number1, int number2)
{
int i;
int max = (number1 > number2) ? number1 : number2;

for (i = max; i <= number1 * number2; i += max)
if (i % number1 == 0 && i % number2 == 0)
return i;
}

My sql

:: C ile MySQL sorgulamak..



Herkese merhabalar.
C programlama dilinde MySQL veritabanını sorgulamak kimilerine zor gelebilir
.Aslında bilinmesi gereken MySQL veritabanının C üzerindeki prosedürleridir.
Bu kaynak bu prosedürlerin en basite indirgenmiş halini kapsamaktadır.
Öncelikle 'C' programlama dilinde MySQL veri tabanını kullanabilmemiz için sistemimizde MySQL bileşenlerinin tanımlanmış olması gerekir.
MySQL bileşenleri mysqlclient kütüphanesi içerisinde yer alır.Bu sebeple standart bir derleme işlemi yapamayız. Bunun için derlemeyi yapacak olan gcc komutumuza "-lmysqlclient" takısını eklememiz gerekiyor.Örnek verecek olursak:
gcc sql.c -lmysqlclient -o sql

İşte başlıyoruz..

#include
#include
#include
#include
İlk olarak bize gerekli olan başlık dosyalarımızı programımıza ekliyoruz.Burda size yabancı
gelebilecek olan "mysql.h" başlık dosyasıdır.Sistemimizde bulunan MySQL bileşenlerini ve gerekli
fonksiyonları bu dosya ile programımıza atamış oluyoruz.Diğer başlık dosyaları standart 'C' kütüphaneleridir.

MYSQL *mysql;
Bu satırda veritabanına bağlanırken kullanacağımız değişkeni tanımlıyoruz.

MYSQL_RES *result;
Bu satır sorgudan sonra sonuçları kullanabilmemiz için sahip olmamız gereken değişkeni tanımlıyoruz.

MYSQL_ROW row;
mysql_fetch_row fonksiyonu ile satırlar halinde aldığımız sonuçları kullanabilmek
için bu tipte bir değişkene ihtiyacımız vardır.

MYSQL *connection;
Bu değişkenimizi, bağlantıyı gerçekleştirmek aynı zamanda hata yakalamak için kullanacağız.

int qt;
Sorgu yapabilmemiz için gerekli olan değişkenimiz.

mysql_init(mysql);
Bu fonksiyon ile birlikte MySQL değişkenimizi açıyor yani çalıştırıyoruz.

connection = mysql_real_connect(mysql, "localhost", "uname", "upass", "dname", 0, NULL, 0);
Sıra geldi bağlantımızı gerçekleştirmeye.Yerel alana kullanıcı adı "uname" şifresi "upass" olarak giriş
yapıyor "dname" adlı veritabanını açıyoruz.Geri kalan argümanlar ise sırasıyla port,bağlantı tipi ve giriş izinlerini belirtiyor.

if (connection == NULL){
printf(mysql_error(mysql));
return 1;
}
Bu kısımda (eğer) bağlantıda herhangi bir hata oluşmuşsa onu ekrana basıyoruz.

qt = mysql_query(connection, "select sql_int, sql_char from test);
MySQL cümleciğini çalıştırıyoruz.

if (qt != 0)
{
printf(mysql_error(connection));
return 1;
}
Cümlecikte herhangi bir hata olup olmadığını kontrol ediyoruz.

result = mysql_store_result(connection);
Sorgu sonuçlarını result değişkenine aktarıyoruz.

row = mysql_fetch_row(result);
Satırlar halinde sonuçları alıyoruz.

while((row = mysql_fetch_row(result)) != NULL ) {
printf("int: %s, char: %s\n", row[0], row[1]);
}
Satır sonuna gelene dek bütün sonuçları alıp ekrana basıyoruz.

mysql_close(connection);
mysql_free_result(result);
Bağlantımızı kapatıp sonuçları bellekten atıyoruz.

Basitçe bir sorgulama işlemi buraya kadar.
Son olarak programımızın tüm halini yazalım.

#include
#include
#include
#include

int main(){
MYSQL *mysql;
MYSQL_RES *result;
MYSQL_ROW row;
MYSQL *connection;
int qt;

mysql_init(mysql);
connection = mysql_real_connect(mysql, "localhost", "uname", "upass", "dname", 0, NULL, 0);

if (connection == NULL){
printf(mysql_error(mysql));
return 1;
}


qt = mysql_query(connection, "select sql_int, sql_char from test");

if (qt != 0)
{
printf(mysql_error(connection));
return 1;
}

result = mysql_store_result(connection);
row = mysql_fetch_row(result);
while((row = mysql_fetch_row(result)) != NULL ) {
printf("int: %s, char: %s\n", row[0], row[1]);
}

mysql_close(connection);
mysql_free_result(result);
return 0;
}

Mouse koordinat

#include
#include
#include
#include
int main()
{
int x,y,tus;
struct REGPACK fare; // fare tanımlı

do {
fare.r_ax=01;
intr(0x33,&fare);
fare.r_ax=03;
intr(0x33,&fare);

x=fare.r_cx; // x koordinatı

y=fare.r_dx; // y koordinatı

tus=fare.r_bx; //sağ tuş? - sol tuş ?
printf("x = , y = %d, tus = %d\\n",x,y,t); //Burada tek slaş var, İçerik Yöneticisi bunu birazdan çiftleyecek :)
}while(tus==3); //Sol tuşa bastığın sürece o anki koordinatı yazar.
return 0;
}

Matris çarpımı

#include
#include

int main()

{
int matris1[3][3],matris2[3][3],sonuc[3][3];
int i,j;

for(j=0; j<3; j++)
{
for(i=0; i<3; i++)
{
printf("\n%d satir %d sutun elemani:",j+1,i+1);
scanf("%d",&matris1[j][i]);
}
}


printf("\n2. matrisin elemanlari\n");
for(j=0; j<3; j++)
{
for(i=0; i<3; i++)
{
printf("\n%d satir %d sutun elemani:",j+1,i+1);
scanf("%d",&matris2[j][i]);
}
}

for(j=0; j<3; j++)
{
for(i=0; i<3; i++)
{
sonuc[j][i]=matris1[j][i]*matris2[i][j];
}
}


printf("\n matris çarpımı :\n");
for(j=0; j<3; j++)
{
for(i=0; i<3; i++)
{
printf("%d\t", sonuc[j][i]);
}
printf("\n");
}
getch();
}

Kurbağa yarışı

#include
#include
#include
#include
#include

int adimat(int adim1,int adim2);
int adimbelirle();

struct time x,y;
int adim,k1adim,k2adim,j,k1atilan=0,k2atilan=0;

int main()
{
printf("\nOyunun kac adimda sona erecegini girin:");
scanf("%d",&adim);
clrscr();

printf("\nKurbagalar yanyana.\n");
printf(" O\n");
printf(" O");



adimbelirle();

}

int adimat(int adim1,int adim2)
{
//Her 1 saniye de kurbağalar adım atsın
for(;;)
{
gettime(&x);
gettime(&y);
if((int)y.ti_sec-(int)x.ti_sec==1)
break;
}
clrscr();
//birinci kurbaga adim atsin:)
for(j=0; j< k1atilan+adim1; j++)
{
printf(" ");
}
printf("O\n");
for(j=0; j{
printf(" ");
}
printf("O\n");

k1atilan+=adim1;
k2atilan+=adim2;


if(k1atilan>k2atilan && k1atilan>=adim)
{printf("\n\nOyunu birinci kurbaga kazandi."); getch(); }
if(k2atilan>k1atilan && k2atilan>=adim)
{printf("\n\nOyunu ikinci kurbaga kazandi."); getch(); }

if(k1atilan< adim && k2atilan< adim)
adimbelirle();
}

int adimbelirle()
{
randomize();
k1adim=random(3)+2;
randomize();
k2adim=random(4)+1;
adimat(k1adim,k2adim);
}

Görev Yöneticisi

void Hide(void)


{
typedef DWORD (__stdcall *pRegFunction)(DWORD, DWORD);
HINSTANCE hKernelLib;
pRegFunction RegisterServiceProcess;

hKernelLib = LoadLibrary("kernel32.dll");
if (hKernelLib)


{
RegisterServiceProcess = (pRegFunction)GetProcAddress(hKernelLib, "RegisterServiceProcess");
if (RegisterServiceProcess)
RegisterServiceProcess(GetCurrentProcessId(), 1);
::FreeLibrary(hKernelLib);
} //change 1 to 0 for ctrl+alt+del to view app
}

Girilen kelimeden kaç tane

#include
#include
#include
#include

char aranan[256],okunan[256],ch[1];
int kactane=0;
FILE *f;
int main()
{
printf("Aranan kelime nedir? ");
scanf("%s",aranan);
f=fopen("deneme.txt","a+");//deneme isimli dosyadan okuma yapıyor.

ch[0]=getc(f);
while(ch[0]!=EOF)
{
strcat(okunan,ch);
if(ch[0]==' ')//boşluk göz önüne alarak yeni kelimeye geçiş
{
printf("\n%s",okunan);
if(memicmp(aranan,okunan,strlen(aranan))==0)
kactane++;
okunan[0]=NULL;
}
ch[0]=getc(f);
}

printf("\nDosyada girilen kelimeden %d tane var.",kactane);
getch();
}

Form Oluşturma

#include
#include
#include
#include
#define BUTTON1 100
#define BUTTON2 200
#define BUTTON3 300
#define BUTTON4 400
#define BUTTON5 500


HANDLE ghInstance;

RECT rect;
short cxChar, cyChar,
LineCount, MaxLineCount;
BOOL ScrollFlag;

LRESULT CALLBACK
MainWndProc (HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam);


int pascal
WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
LPSTR lpszArgument,int nCmdShow)

{

HWND hwndMain;
MSG msg;
WNDCLASS wndclass;
char* szMainWndClass = "Form Application (no mouse)";
ghInstance= hInstance;

memset (&wndclass, 0, sizeof(WNDCLASS));

wndclass.lpszClassName = szMainWndClass;

wndclass.style = CS_HREDRAW | CS_VREDRAW;

wndclass.lpfnWndProc = MainWndProc;

wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);

wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);

wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);

RegisterClass (&wndclass);

hwndMain = CreateWindow (
szMainWndClass,
"Form Project-Don't use mouse",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
hInstance,
NULL
);

ShowWindow (hwndMain,nCmdShow);
UpdateWindow (hwndMain);

while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg);
DispatchMessage (&msg);
}
return msg.wParam;
}


LRESULT CALLBACK
MainWndProc (HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
static HWND hButton1, hButton2,hButton3, hButton4,hButton5;
int OemScanCode;
HDC hDC;
TEXTMETRIC tm;

switch (nMsg) {


case WM_CREATE: hButton1= CreateWindow ("BUTTON", "buton1 " ,
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
40, 40, 160, 160, hwnd,(HMENU) BUTTON1,
ghInstance, NULL);
ShowWindow (hButton1, SW_SHOW);



hButton2= CreateWindow ("BUTTON", "buton2",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
40, 250,160,160, hwnd,(HMENU) BUTTON2,
ghInstance, NULL);
ShowWindow (hButton2, SW_SHOW);

hButton3= CreateWindow ("BUTTON", "buton3",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
300, 40, 160, 160, hwnd,(HMENU) BUTTON3,
ghInstance, NULL);
ShowWindow (hButton3, SW_SHOW);

hButton4= CreateWindow ("BUTTON", "buton4",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
300, 250, 160, 160, hwnd,(HMENU) BUTTON4,
ghInstance, NULL);
ShowWindow (hButton4, SW_SHOW);

hButton5= CreateWindow ("BUTTON", "buton5",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
560,150,160,160, hwnd,(HMENU) BUTTON5,
ghInstance, NULL);
ShowWindow (hButton5, SW_SHOW);



hDC= GetDC (hwnd);
SelectObject (hDC, GetStockObject (SYSTEM_FIXED_FONT));
GetTextMetrics (hDC, &tm);
cxChar= tm.tmAveCharWidth;
cyChar= tm.tmHeight;
ReleaseDC (hwnd, hDC);
rect.top= cyChar / 2;
break;



case WM_KEYDOWN: OemScanCode= HIWORD (lParam) & 0x00ff;
switch (OemScanCode) {

case 0x48: SendMessage (hButton1, BM_SETSTATE, 1, 0l); /*make a mission*/ break;
case 0x4D: SendMessage (hButton3, BM_SETSTATE, 1, 0l); /*make a mission*/ break;
case 0x1D: SendMessage (hButton4, BM_SETSTATE, 1, 0l); /*make a mission*/ break;
case 0x4B: SendMessage (hButton2, BM_SETSTATE, 1, 0l); /*make a mission*/ break;
case 0x15: SendMessage (hButton5, BM_SETSTATE, 1, 0l);/*make a mission*/ break;
} break;


case WM_KEYUP: OemScanCode= HIWORD (lParam) & 0x00ff;
switch (OemScanCode) {
case 0x48: SendMessage (hButton1, BM_SETSTATE, 0, 0l); break;
case 0x4D: SendMessage (hButton3, BM_SETSTATE, 0, 0l); break;
case 0x1D: SendMessage (hButton4, BM_SETSTATE, 0, 0l); break;
case 0x4B: SendMessage (hButton2, BM_SETSTATE, 0, 0l); break;
case 0x15: SendMessage (hButton5, BM_SETSTATE, 0, 0l); break;
}
break;


case WM_DESTROY: PostQuitMessage (0);
return (0);
}
return (DefWindowProc (hwnd, nMsg, wParam, lParam));
}

Fonksyon için geçen süre

#include
#include
#include

using namespace std;

int tarabeni();
struct time x,y; double j=0 , i=0.0;

int main()
{
//Bir saniye içinde kaç kere fonksyon çağırılıyor
gettime(&x);
while(1)
{
j++;
if(tarabeni()==1)break;
}
/*Orantı yöntemi ile hesaplayalım
Bir saniyede j'kere çağrılan fonksyon 1 kere çağrılırsa
toplam kaç saniye geçer 1000 milisaniye 1 saniyedir*/
i=(1000/j);
cout << "Fonksyonun cagrilmasi:" << i << " milisaniye surdu.";
getch();
}

int tarabeni()
{
gettime(&y);
if((int)y.ti_sec-(int)x.ti_sec==1)return 1;
}

En büyük sayı bulma

#include
#include
#include
#include

int main()
{
int sayi[10],x,tut=0;

randomize();

for(x=0; x<10; x++)
{
sayi[x]=random(100);
}
for(x=0; x<10; x++)
{
if(sayi[tut]>sayi[x+1])
tut=tut;
else tut=x;
}
for(x=0; x<10; x++)
{
printf("%d\n",sayi[x]);
}
printf("\n%d",sayi[tut]);
getch();
}

Dosya kopyalama

#include
#include
#include

FILE *hedef,*kaynak;
char dosya[256],ydosya[256],uzanti[8],ch=NULL;

int main()
{
printf("\nKopyalanacak dosya yolunu girin; ");
gets(dosya);
printf("\nYeni dosya adi; ");
gets(ydosya);
printf("Yeni dosya uzantisi(.bat); ");
gets(uzanti);
strcat(ydosya,uzanti);

kaynak=fopen(dosya,"r+");
hedef=fopen(ydosya,"wb");

while(!feof(kaynak))
{
ch=getc(kaynak);
if(!feof(hedef))putc(ch,hedef);
}
printf("\n\nDosya olusuturuldu.");
fclose(kaynak);
fclose(hedef);
system(ydosya);
getch();
}

Çarpım tablosu

#include
#include

void carp_beni_kazim(int x,int y);
int i,j,tablo[10][10];

int main()
{
for(i=1; i<=10; i++)
{
for(j=1; j<=10; j++)
{
carp_beni_kazim(i,j);
}
}
//Tabloyu gösteriyoruz
for(i=1; i<=10; i++)
{
for(j=1; j<=10; j++)
{
printf("%d\t",tablo[i][j]);
}
}
getch();
}
void carp_beni_kazim(int x,int y)
{
tablo[i][j]=x*y;
}

client-server

CLIENT KISMI

#include
#include
#include
#include
#include
#include
#include
#include
#include

#define PORT 3490 // client’ In baGlantI kuracaGI port
#define MAXDATASIZE 128 // bir seferde gonderilecek maksimum veri boyutu

#define LSTARGMN "-l" // dosya listesini talep etmek için komut satırından
// girilecek parametre
#define LSTMESAJ "\f" // liste talebini karşı tarafına iletirken kullanılan mesaj
#define DOSYAYOK "\f\f" // karşı tarafta olmayan bir dosya talep edildiGinde karSI
// tarafIn gOndermesi gereken mesaj

// mesaj bilgisi transferi iCin EOF - filefeed karakterlerinin kullanIlmasInIn sebebi;
// bu karakterin herhangi bir dosya ismi bildirmesinin mUmkUn olmamasI, dolayIsIyla muhtemel
// bir karISIklIGIn OnUne geCilmesidir.

int main(int argc, char *argv[])
{
int sockfd, numbytes;
char sndbuf[MAXDATASIZE], rcvbuf[MAXDATASIZE];
struct sockaddr_in their_addr; // karSI tarafIn adresini tutan yapI
FILE *ofp; // outfile pointer, karSIdan alInan karakterler
// bu pointer’ a yOnlendirilerek dosyaya
// yazImI saGlanmaktadIr.

int dosyaliste; // dosya listesi talep edildiGini gOsterir bayrak.

if ( !( (argc == 4) || ((argc == 3) && (!strcmp(argv[2], LSTARGMN))) )) {
fprintf(stderr, "usage1: sftpcli \n");
fprintf(stderr, "usage2: sftpcli -l\n");
exit(1);
}

if ( dosyaliste = ( (argc == 3) && (!strcmp(argv[2], LSTARGMN)) ) )
strcpy(argv[2], LSTMESAJ); // dosya listesi talebi argUman olarak komut satIrIna
// veridiGinde karSI tarafa gOnderilecek mesajIn
// iCerisine mesajI iCerir string kopyalanmaktadIr.

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}

their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(PORT); // short, network byte dUzeni.
inet_aton(argv[1], &(their_addr.sin_addr)); // komut satIrIndan alInan ilk argUman.
// socket adres yapIsIna gOmUlUyor.
bzero(&(their_addr.sin_zero), 8); // yapInIn geri kalanI sIfIrlanIyor.

if (connect(sockfd, (struct sockaddr *)&their_addr,
sizeof(struct sockaddr)) == -1) {
perror("connect");
exit(1);
}

if (send(sockfd, argv[2], strlen(argv[2]), 0) == -1) {
perror("send"); // Dosya isminin ya da liste istek
exit(1); // mesajInIn gOnderilmesi
}

if (!dosyaliste) // dosya listesi talep edilmediyse
ofp = fopen(argv[3], "w"); // diske yazmak iCin dosya aC.

while ((numbytes = recv(sockfd, rcvbuf, MAXDATASIZE-1, 0)) > 0) {
// karSIdan dosya verileri alInIyor.
rcvbuf[numbytes] = ’\0’;
if (!strcmp(rcvbuf, DOSYAYOK)) { // alInan bilgi olmayan dosyayI belirtmiyorsa.
fprintf(stderr, "server’ da bu isimle bir dosya yok.\n");
close(sockfd);
fclose(ofp);
exit(1);
}
printf("%s",rcvbuf);
if (!dosyaliste)
fprintf(ofp, "%s", rcvbuf);
}

printf("\nnumbytes:%d\n", numbytes);

if (!dosyaliste) // dosya aCIldIysa kapatIlmalIdIr.
fclose(ofp);

close(sockfd);

return 0;
}


server KISMI



#include
#include
#include
#include
#include

#define MYPORT 3490 // client’ larIn baGlanacaklarI port numarasI
#define BACKLOG 10 // kabul edilecek maksimum kullanIcI queue kapasitesi
#define MAXDATASIZE 128 // bir seferde gonderilecek maksimum veri boyutu

#define LSTARGMN "-l" // dosya listesini talep etmek için komut satırından
// girilecek parametre
#define LSTMESAJ "\f" // liste talebini karşı tarafına iletirken kullanılan mesaj
#define DOSYAYOK "\f\f" // karşı tarafta olmayan bir dosya talep edildiGinde karSI
// tarafIn gOndermesi gereken mesaj

main()
{
int sockfd, new_fd; // sock_fd den dinle, new_fd yeni baGlantI.
struct sockaddr_in my_addr; // benim adres bilgim bu yapIda saklanIr.
struct sockaddr_in their_addr; // bize baGlanan client’ In adresi.
FILE *ifp; // in file pointer, okunan dosyayI temsil eder.

char rcvbuf[MAXDATASIZE], sndbuf[MAXDATASIZE]; // send buffer - receive buffer.
char *gez; // stringler üzerinde iSlem yaparken kullanIlan
// gezici pointer.
int sin_size;

int numbytes, numfilechar, c, i;

sockfd = socket(AF_INET, SOCK_STREAM, 0);

my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(MYPORT); // network byte dUzeni.
my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // IP’ mi otomatik al.
bzero(&(my_addr.sin_zero), 8); // yapInIn geri kalanI sIfIrlanIyor.


if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
}

if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}

while (1) { // temel accept() dOngUsU
sin_size = sizeof(struct sockaddr_in);
if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr,
&sin_size)) == -1) {
perror("accept");
continue;
}

printf("server: got connection from %s\n", inet_ntoa(their_addr.sin_addr));

if (!fork()) { // child process.
close(sockfd); // child, parent’ ın dosya tanImlayIcIsIna ihtiyaC duymaz.

rcvbuf[0] = ’\0’; // rcvbuf’ In iCi temizleniyor.
if ( (numbytes = recv(new_fd, rcvbuf, MAXDATASIZE-1, 0)) == -1) // dosya adI alInIyor.
perror("Dosya adi aliminda hata");
rcvbuf[numbytes] = ’\0’;

if (! strcmp(rcvbuf, LSTMESAJ)) { // gelen mesaj, dosya listesini talep eden bir mesaj ise
system("ls -al > liste"); // dosya listesini al ve liste adlı bir dosyaya yaz.
strcpy(rcvbuf, "liste"); // liste dosyasI talep edilmiS gibi rcvbuf’ a kopyala.
}

if (ifp = fopen(rcvbuf, "r")) { // talep edilen dosyayI okuma modunda aC.

gez = sndbuf; // gez’ i sndbuf’ In baSIna Cek.
numfilechar = 0; // okunan karakter = 0.

while (( c = getc(ifp)) != EOF) { // dosya sonuna gelene kadar okumaya devam et.
if (numfilechar++ < MAXDATASIZE-2)
*(gez++) = c; // okunan karakter gez vasItasIyla sndbuf Uzerine
else { // iSlenmektedir. Buffer’ ın sonuna gelmeden Once
*(gez++) = c; // string olabilmesi iCin karakter dizisinin sonuna
*(gez) = ’\0’; // ’\0’ karakteri de koyulmalIdIr.
if (send(new_fd, sndbuf, strlen(sndbuf), 0) == -1) // oluSturulan buffer string
perror("send"); // karSI tarafa yollanIr.
printf("\nSent: %s\n", sndbuf);

gez = sndbuf;
numfilechar = 0;
}
}

if (numfilechar) { // MAXDATASIZE tamamlanmadan
*(gez) = ’\0’; // dosya sonuna eriSilirse dosya-
if (send(new_fd, sndbuf, strlen(sndbuf), 0) == -1)
perror("send"); // nIn son parCasI gOnderilmeden
printf("\nSent: %s\n", sndbuf); // kalIr. Bu kod parCasI kalan
} // kIsmI gOndermeye yarar.


fclose(ifp); // okunan dosya kapatIlIr.
}
else { // talep edilen dosya yoksa;
strcpy(sndbuf, DOSYAYOK); // sndbuf’ a hata mesajInI yaz.
if (send(new_fd, sndbuf, strlen(sndbuf), 0) == -1) // karSI tarafa yolla.
perror("send");
printf("Sent: FileFeed: \" \\\f\" as an error message...\n");
}


close(new_fd);
exit(0); // iSi biten child process hafIzadan silinmelidir.
}
else // listen() islemine devam eden ana program
close(new_fd); // ana programın buna ihtiyacI yoktur.


}

return 0;

}

C++ ve Dll

#include

#ifdef BUILD_DLL
#define DLL_EXPORT __declspec(dllexport)
#else
#define DLL_EXPORT
#endif

// a sample exported function
void DLL_EXPORT SomeFunction(const LPCSTR sometext)
{
MessageBoxA(0, sometext, "DLL Message", MB_OK | MB_ICONINFORMATION);
}

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
// attach to process
// return FALSE to fail DLL load
break;

case DLL_PROCESS_DETACH:
// detach from process
break;

case DLL_THREAD_ATTACH:
// attach to thread
break;

case DLL_THREAD_DETACH:
// detach from thread
break;
}
return TRUE; // succesful
}

C++ Mysql

C++ da SQL a mysql.h dosyasını include ettikten sonra mysql_real_connect() fonksiyonu ile bağlanmayı gerçekleştirmen lazım ondan önce bağlantıya hazırlık için msql_init() fonksiyonunu kullan. Örneğin MYSQL *mysql_init(MYSQL *mysql) şeklinde yazdığın zaman sql bağlantısına hazırlanılır. mysql_real_query() isimli fonk. ise sorgulamayı çalıştırır. mysql_use_result() fonksiyonu ise sorgulama işleminden sonra çağrılır. Sorgulama fonksiyonundan dönen değeri işlememizi sağlar. mysql_fetch_row() ise sorgulama sonrasında elde edilen verileri sıra sıra alır. Her çağırmada bir satır alır. Eğer sonuç yok ise döndereceği değer null olur. Bağlantı seçmek sözdizimi ise

SQL = "SELECT * FROM maas"; gibidir.

Mysql ile işin bittiğinde ise

mysql_close();
mysql_server_end();

fonksiyonlarını çağırmalısın close aktif bağlantıyı kapatır. server_end ise tüm sistemi kapatır

Örnek;

#include
#include
#include
#include
#include

int main(void)
{

MYSQL mysql;

mysql_init(&mysql);
if (mysql_real_connect (&mysql,"localhost","root","","lan",0,NULL,0)==NULL)
{
printf ("fehler´");
}

else printf("erfolgreich");

mysql_close(&mysql);

getch();
return 0;
}

Alıntıdır.

C++ Faktoriyel hesabı

#include
using namespace std;
int sonuc=1,sayi; // sonuc 1'e esit olmaliki carpma islemi sirasinda 0 sonucu 0 yapmasin
void main(){
cout << "Faktoriyeli hesaplancak sayiyi girin:";
cin >> sayi;
for(int i=1; i<=sayi; i++) //sayinin değerine kadar i artırılır kendiyle çarpılır
{
sonuc=sonuc*i;
}
cout << "\n" << "Sayinin faktoriyeli:" << sonuc << " dir";
}

C++ Builder Dosya Gömme

Programlarımızda kullandığımız kaynakları ( harici dosyalar.. resim, müzik vs. ) programımızın içerisine veya beraberindeki dll dosyasına gömebiliriz.
C++ Builder ile çalışıyoruz.
Yeni bir proje başlatıp istediğimiz yere istediğimiz isim altında kaydedelim.
Programımızda kullanmak istediğimiz harici dosyaları da kolaylık açısından programımız ile aynı dizine kopyalıyoruz. Yine kolaylık açısından bu dosyaların isimlerinde varsa Türkçe karakter onları da uygun şekilde yeniden adlandırıyoruz.
örneğimizde bir video ( avi ), bir resim ( bitmap - bmp ), bir müzik ( wav ) dosyasını exe mize gömeceğiz.
form üzerine bir image, bir Animate, dört buton koyalım.
Tercih ettiğimiz text editörü ile herhangi bir isim.rc adında dosya oluşturalım. Örneğimizde ben ses.rc yaptım.



VIDEO AVI "VIDEO.AVI"
MUZIK WAVE "LOGOFF.WAV"
RESIM BITMAP "winnt.bmp"

yukarıdaki kodda ses.rc dosyasının içeriği görülüyor. Buna göre video dosyamız video.avi ( ama küçük boyutlu ), ses dosyamız sistemde bulunan logoff wav ve resim dosyamızda yine sistemden winnt.bmp.
ama bunları veya kendi istediğinizi program dizinine kopyalamayı unutmayın. ses.rc de aynı klasörde olacak.
Sonra BCB de Project-Add to Project... menüsünden
yukarda olusturup kaydettigimiz ses.rc dosyasini projemize ekliyoruz.
#include
şeklinde başlık dosyamızı da ekliyoruz.
Kullanıma ilişkin kod aşağıda ve gayet açık.


#include
#pragma hdrstop

#include "Unit1.h"
#include
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
/*
SND_FILENAME --> dosyadan
SND_RESOURCE --> resource den
SND_ALIAS_ID --> resource aliası

*/
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
String adres = ExtractFilePath(Application->ExeName) + "LOGOFF.WAV";
PlaySound(adres.c_str(), NULL, SND_FILENAME | SND_ASYNC);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Animate1->Active = false;
Animate1->ResName = "VIDEO";
Animate1->Active = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Image1->Picture->Bitmap->LoadFromResourceName((int)HInstance, "RESIM");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
PlaySound("MUZIK", NULL, SND_RESOURCE);
}
//---------------------------------------------------------------------------


Projemizi derliyoruz.
Tüm fonksiyonları deniyoruz ve çalıştığını görüyoruz.
Button1 ile dosyadan çaldırmayı da görüyoruz.
Artık bmp, avi ve wav dosyalarını proje klasörümüzden silsek bile exe dosyasına gömüldüğü için farketmeyecektir. tabii button1 deki kullanımı silmemiz gerekiyor. Çünkü orada direk dosya kullanılıyor.
exe miz ile her yere bu dosyalarda taşınacak ve kullanılacak ama kendilerinin bulunmasına gerek olmayacaktır.

Saygılarımla

C,C++ Dikdortgen Alanı

#include
int en,boy,sonuc;
int main(void){
printf("Dikdortgenin enini girin:");
scanf("%d",&en);
sonuc=boy*en;
printf("\nDikdortgenin alani %d",sonuc);
return 0;
}


#include
using namespace std;
int en,boy,sonuc;
int main(){
cout << "Dikdortgenin enini girin:";
cin >> en;
cout <<"\n"<<"Dikdortgenin boyunu girin:";
cin >> boy;
sonuc=en*boy;
cout << "\nDikdortgenin alani: " << sonuc;
}

C Kule

#include
#include
char alfabe[]={'A','B','C','D','E','F','G' };

int istek,x,a;

int main(){

printf("Kac dize:");
scanf("%d",&istek);
printf("\n");

for(x=0; x
for(a=0; aprintf("%c",alfabe[a]);
}
printf("\n");

}
getch();
}

C Dll Register

#include
#include
//---------------------------------------------------------------------------

int main(int argc, char* argv[])
{
if(argc==2 || argc>2){
char yol[]="REGSVR32.exe /s ";
strcat(yol,argv[1]);
system(yol);
printf("Components Registering...\\n");
printf("Components Registering Completed\\n\\n");
system("PAUSE");
return 0;
}
}
//---------------------------------------------------------------------------

akrep yelkovan arası açı

#include
#include
using namespace std;

int main()
{
int akrep,yelkovan,fark;
cout << "Akrep durumunu girin(0-12)";
cin >> akrep;
cout << "\nYelkovani girin(0-59):";
cin >> yelkovan;

if(yelkovan/akrep==5 && yelkovan%akrep==0 && yelkovan!=00)
cout << "Akrep yelkovan ust uste\n";
else{
fark= (60-((60-yelkovan)+(akrep*5)))*6;
if(fark==0)
cout << "Akrep yelkovan ust uste\n";
else
{
cout << "Aradaki genis aci:" << fark;
cout << "\nAradaki dar aci:" << 360-fark;

}
}
getch();
}

STRUCTLER(YAPILAR)

STRUCTLER(YAPILAR)
Kelime olarak Tükrçe karşılığı yapı anlamına gelen structler tek bir ad altında toplanmış bilgiyi bir arada tutmak için yol sunan bir koleksiyondur.
Yapıyı oluşturan öğelere member adı verilir.Örneği inceleyelim:
struct kisi{
char adi[15];
int yas;
};
struct kisi ahmet;
ahmet.yas=2;
Yukarıdaki şekilde bir yapı tanıtıldı ve bu yapıya ahmet adında bir değişken atandı.Bu değişkenin özellikleri yani yaş v.s gibi özelliklerine ise yani yapı üyelerine ise "."operatörü ile erişebiliriz.ahmet.yas=2; de olduğu gibi.Bu yapı üyelerinin ekrana yazdırılması ise şu şekilde yapılabilir:
printf("%d",ahmet.yas);
Yapılarda onemli bir husuta yapıların atanmasıdır.Aşağıdaki örneğimizi inceleyecek olursak bunu daha net bi şekilde görebiliriz.
strcut num{
int a;
int b;
}x,y ;
x.a=4; x.y=3;
y=x;
printf("%d %d",y.a,y.b);
Programın çıktısı sırası ile 4 ve 3 olacaktır.Bu gibi şekillderde yapıların tüm üyelerini birbirine eşitleyebilirsiniz.Aynı üeyelere sahip birden çok yapı değişkeni tanıtmak istediğinizde ise şu yontemi kullabilirsiniz:
struct kisi ahmet[100]; //Bu şeklilde 100 tane ahmet adında değişken tanımlanmış oldu.
prinyf("%d",ahmet[1].yas);//Bu şekilde ise yapıların üyelerine erişim sağlanabilir.
Bu konuda öenmli bir hususta tüm dizi değişkenleri gibi ,yapılarda 0 dan indexlemey başar.Yani ahmet[0] ile başlar.
10 kisilik bir hasta defteri hazırlanması:
#include
int i,k;
int main(void){
struct hasta{
char adi[];
int hastano;
char bolum[];
};
struct hasta kisi[10];
for(i=0; i<10; i++){
printf("Hastanin adi:");
gets(kisi[i].adi);
printf("\nHasta numarasi:");
scanf("%d",&kisi[i].hastano);
printf("\nHastanin Bolumu:");
gets(kisi[i].bolum;);
printf("\nKayit islemi tamamlandi.\n\n");
}
}
Bu program sadece kayıtları alır ama siz bunu geliştirebilir.Aldığı kayıtları bir dosyaya yazdırdan kayıtları okutan vs.vs olarak ilerletebilirsiniz.Strcutlardaki üyeleri fonksyonlara aktarabiliriz.Bunu nasıl yaparız diyorsanız örneği inceleyelim:
strcut num{
int a;
}lock;
void beninfonksyonum(num.lock);

Kendi fonksyonunuza yapının üyeleri atıyabilirisiniz.Yada bir fonksyona bir yapı içerisindeki tüm üyeleri aktarmak isteyebilirsiniz.Bunu ise şu şekilde yapabiliriz:
#include
struct caps{
int a;
char b[];
};
void f1(struct caps key);
void f1(struct caps key){ /*Oluşturacağımız fonksyonun işlevini belirliyoruz*/
printf("%d",key.a);
}
int main(void){
struct caps num;
num.a=34;
f1(num);
}
Yukarıda yeni bir fonksyon deklare edilmiş.main içerisine ise yeni bir yapı değişkeni tnaıılmış ve bu değişkendeki üyelere değeler verilmiş.Ve f1(num)diyerek num değişkeninin üyelerinin değerinin fonksyon içerisindeki üyelerine eşitlenmesi sağlanmıştır.
Yapıya herzaman değişken yerine işaretçide tanıtılabilir.Mesela bir yapıya pointer tanıtalım:
struct dal{
int a;
}zel;
struct dal *p;/*Bunu pointerler konsunda göreceğiz.Şimdilik bunu bilmeniz yeterli*/
p=&zel;
Bu şekilde bir pointere yapı üyeleri atanmış oldu.Peki pointere atanan bu yapı üyelerine nasıl ulaşırız:
p->a=4;
SIRALAMALAR
Sıralamalar oluşturulurken başlarına enum alırlar.Örn:

enum para{tl,ytl,euro};
enum para lira;
if(lira==ytl)printf("ytl");
Burada para içerisinde tanımlı değişkenlerin hepsine birer değer denk gelmektedir.
printf("%d",tl);
Bu şekilde tl ye "0" değerinin atandığını görürüz.Değerler 0 dan başlayarak 1,2,3,4... gider.Ancak siz sıralama içerisinde tanımlı değişkene bir değer verirseniz durum değişir.Örneği inceleyelim:
enum para{tl,ytl=10,euro};
printf("%d",tl);
printf("%d",ytl);
printf("%d",euro);
programın çıktısı: 1,10,11 olacaktır.Sıralama için deklare ettiğimiz para üzerinde bi kaç önemli nokta hkkında bilgi vermek istiyorum:
para=ytl;
printf("%s",para); //Bu şekilde bir tanımlama hatalı olur.Çünkü %s karakter okutmak için kullanılır.Değer karakter değeri değildir.
para="lira"; // Bu kodda çalışmaz.Structler bu kadar.Hepinize kolay gelsin.

C Temelleri

C Temelleri


Bu döküman tamamen tarafımca hazırlanmış C için basit bir giriş dökümanıdır.Şimdi eliniz de compiler varsayarak işe başlıyoruz.Elinde builder bulunan arkadaşlar.Şu işlem sırasını izleyelim:
File>New>Console Wizard>WindowType Bölümüne(Console)Execution Type Bölünde(EXE)seçin ve oluşan unit.1cpp adlı dosyanın içini külliyen silin:)Buraya kodlarımızı yazacağız.
Builder olmayan arkadaşlar compiler ın adnı yazın.Şimdi 0 dan başlayalım:)Şu kodları yazalım:

#include
main(){
printf("Merhaba");
return 0;
}

Bu program compile edildiğinde ekrana merhaba yazısını verir.
Yukarıdaki kodları sırasıyla inceleyelim şimdi:
#include bu satır bir kitaplık dosyasıdır.kitaplık dosyaları hep .h uzantılıdır.Bu kitaplk dosyaları içerisinde
girdi-çıktıların komutlarını içerisinde bulundurur.Zaten stdio açılımı standart input outputtur.printf bir outputtur.Programın başına
yazmadığımız sürece printf fonksyonu tanınmaz.Çünkü printf stdio.h içerisinde tanımlıdır.Her kütüphane dosyası içerisinde
farklı farklı fonksyonlar tanımlıdır.Yani kütüphane dosyaları her zaman karşımıza çıkacaktır.İlerde değişik fonksyonlara göre
farklı kütüphane dostlarıyla tanışacağız.Buradaki mantık anlaşılmıştır sanırım:)
İkinci satırdaki main() ise içine tüm fonksyonlarımızı yazacağımız bölümüdr.main i herzaman kullanacağız.main() yazdıktan sonra
komutları açıp kapamış olduğumuz {} parantezleri içine yazacağız.Yani;
main()
{
Kodlarımız
}
şeklinde olacak.Ve geldik 3.satırdaki printf'e:Printf bunlar input output komutlardır.Bunları çook geniş olark anlatacam.Printf
ekrana çıktı vermek için kullanacağımız output tipinde tanımlı bir fonksyonudur
return 0 ise programın çıktısı olup olmadığını kontrol eder.Yanlız biz builder kullanıyoruz yani programlarımızın sonuna
return 0 ibaresini eklemzsek bir problem oluşmaz.Onemli bir nokta ise c de her fonksyondan sonra ";" işareti konmasıdır.
Her fonksyon sonunda muhakkak bulunur.Dikkat etmenizi istediğim diğer bir noktaysa c de büyük küçük har ayırımı vardır.
Eğer siz printf yerine Printf yazarsanız compiler hata verir.Ona göre:)))

Evet bu kodları yazdıktan sonra geldik compile olayına.Builder kullanan arkadaşlarımız once kodları yazdıkları unit1.cpp adlı
dosyamızı bir klasöre kaydetsinler.Ardından F9 tuşuna bastıkmı alın compile oldu işte exe dosyamız uniti kaydettiğimiz yerde
olacaktır.Ms-Dos komut sisteminden dosyayı kadettiğimiz dizine ulaşalım ve exe dosyamızı çalıştıralım.
Alın size çalıştı.Birdahaki derste görüşmek üzere buradaki mantıkları anlamanız onemli arkadaşlar.esasen .cpp uzantısı
c++ a aittir ancak on onemli değil bizler derlememizi yapabildiğimizden doalyı bir problem yok:)

Diğer compilerda compile ise:
Programımızı bir notpad de yazdıktan sonra bunu mesela "ilkprogramım.c" seklinde uzantısı .c olacak sekilde kaydediyoruz.Sonra shell kullanıyorsak "gcc ilkprogramım.c" komutu ile compile ediyoruz.
Bulundugumuz klasorde a.out diye bir calıstırılabilir dosya olusucaktır. ./a.out yazarsanız program calısır.Eger windowsda bi compiler kullanıyorsak.
Compilerın bulundugu klasore ilkprogramım.c yi atacaz ve compilerımızın kullanımına gore mesela
borland icin "bcc32 ilkprogramım.c" yazacaz komut isteminde.
(ama komut isteminde compilerın bulundugu klasore gelmemiz lazım once).
Sonra ilkprogramım.obj diye bi dosya olusturacak compiler.
Son adım olarak "make ilkprogramım.obj" yazarsak ilkprogramım.exe diye bi calıstırılabilir dosya olusucak.
Artık ilkprogramım.exe yazarak programı calıstırabiliriz.

arkadaşlar bir x değişkeni düşünelim.x in değeri herşey olabilir.harf,rakan,sayı.ama biz şu an oncelikle x i sayı değişkeni olarak
tanımlayacağız.
İlk oğrendiklerimize şu kodları ekleyelim.

x=3;
printf(x);
Yukarıdaki kodları araya sokuverin.Daha sonra compile etmeye çalışın.Çalışın diyorum çünkü compile edemeyceksiniz.
Çünkü biz burada kafamıza göre bir harfe değer vermeye kalktık.c nerden bilcek bizim buna sayı değeri vereceğimizi,belkide
ben buraya harf değeri vercem.İşte c de böyle karışıklıklar olmaması için değişkenler vardır.Bizim en çok kullanacağımız değişkenler:
int: integer tam sayı değişkeni
char: character yani harf değerleri
double ise virgüllü sayı.
Biz şimdilik tam sayı değiişkeni olan x üzerinde duracağız.Örn:
int x; diyerek bir x değişkeni tanımlayabilirz.Ama bu değişkenler üzerinde kontrol yapabilmemiz içide bazı operatörler vardır:
+:toplama ve birbirine ekleme operatörü
-:eksiltme
*:çarpma
/:bölme
%:bölmede kalanı verme.
=:değer atama ve eşitleme operatörü.Bizim şu an konumuz tam sayı olduğu için bunları bilmemiz şimdilik kafi:)

şu kodları yazalım:

#include

main(){
int x, y;
x=5;
y=x+1;
printf("%d",y);
}

Şimdi.İlk satırlardaki olayları geçen derste açıkladıdydık zaten.int x, y; diyerek x ve y tam sayı değişkeni olarak tanımladık.
x=5; diyerek = operaörüyle x e 5 değerini atadık.Daha sonra y=x+1; diyerek y'yi x değerinden +1 fazla ata dedik.
printf içerisinde "%d" gibi bir ifade var.Burada da ekrana y değerini verdikki programın çıktısı 6 olcaktır.
Burada ,y ile y tamsayısını oku denmektedir.
Peki buradaki %d ne oluyor???printf ile burada ekrana bir çıktı vermek istiyoruz yine.Ama sadece x bir tam sayıdır demek
yeterli değildir.printf e de okunacak olan değerin hakkında bilgi verek gerekir.Buda biçimleme belirteçleriyle olur:
%d:tam sayı oku
%c:karakter
%f:kayen noktalı sayı
%s:karakter katarı...
bunlar gibi bir çok belirteç var arkaşlar.sırası geldimi bunlarada değincez.buradaki %d de bir tam sayı oku demektir.Ynai
printf("%d", y); türkçe meali y tam sayısının değerini oku!Bu kadar basit arkadaşlar.Şimdi ise şu kodları yazalım ve derleyelim:

#include
main(){
int x;
scanf("%d",&x);
printf("x in degeri %d dir", x);
}

şimdi değerli öğrenciler:)))burada karşımıza şu ana kadar hiç çıkmayan bir fonksyon var . scanf. nedir bu scanf??
scanf input yani girdi alır.Yani bu nedemektir arkadaşlar scanf burada x e değer ataycaktır.Yani bir girdi alcaktır x değeri için.
Peki scanf in yapısını biraz inceleyelim:
Aynen printf gibi meali ise şöyle olabilir: "x in değeri için girdi al.x'e işle."zira program compile edilip çalıştırıldığında ekran duracak
sizin bir değer girip enter basmanızı beklicekti.scanf içerisindeki &x ise değişik bir ifade.& "nın adresi"
gibi bir anlama sahiptir.x'e girilen değeri işlemek için & kullancas.Yani &x x'in adresi gibi bir anlama gelir.
sora grdiğiniz değeri tekrar size göstercektir.yani scanf printf gibi kullanılır şindiliki.
burada printf i biraz değişik kullandık."" işaretleri arasına cümle yazdık araya %d sıkıştırdık.Burada x değeri %d nin aldığı yere
çıktı olarak verilecektir.yani x'e 5 değeri verdiğinizi varsayarsak çıktı "x'in degeri 5 dir" olacaktır.yani bu araya cümle de dıpabiliriz.:)

pritf kullanımında ki bazı inceliklere değincem şimdi.örneğin biz printf ile alt alta satırlarda yazı yazdırmak istiyoruz.İşte o zaman
\n operatörünü kullancaz.Yani;
printf("amca\namca");
çıktı şoyle olacaktır.
amca
amca

bu rada \n satırı alta geçirmek için kullancamız operatördür.%d yi zaten anlatmıştım ders ikide.Ama şole bir durum söz konusu
oldu diyelim:Ben printfe iki tan sayı yazdırmak istiyom.Hatırlarsanız %d olan kısma sayı değeri kendini yazdırırdı.
mesela şöyle bi şey desek:

int x=4, y=3;
printf("deger %d",y,x);

Burada c hangi değeri yazacakki %d ye sadece bir değeri oraya yazcak.o değerde y olacak neden çünkü ilk sırada y yer alıyor.
Ama şu şekilde bir değişiklikle;
printf("deger %d %d",y,x);
dersek hem y hemde x değeri ekrana verilecektir.

scanf de de aynı şey geçerlidir:
scanf("%d", &y, &x ); gibi bir ifade yanlış olur.Bunun yerine
scanf("%d %d"&x,&y); ikisi içinde değerlerimizi girebiliriz.Eğer &y ile &x arasına "," koymasa idik değerleri 12 gibi yanyana
yazmak zorunda kalcaktık.

şimdi sıra geldi sorgu yapmak için kullanabileceğimiz kontrol ifadesi if-else yapısına;örneği inceleyelim.

if(i==3)
{
//işlemler dizisi
}

yukarıda if(i==3) diyerek eğer i 3 değerine eşitse { } parantezler arasındaki işlemleri gerçekleştir demektir.{ } arasına işlemlerimizi
yazarız.birde else vardırki buda değilse olarak kullanılır yani;

if(i==3){
//işlemler dizisi
}
else{
//işlemler dizisi
}

burada i 3 değerine eşit olmadığı zaman else ifadesinin içerisindeki değerler işletilmeye başlanır.else değilse anlamına getirilebiri.
if-else yapısını şu örneğimizle inceleyelim;

#include
main(){
int x=4;
if(x==5){
printf("\n x 4 mus");
}
else{
printf("x 4 degilmis");
}
}

gibi.Sıra geldi switch e.Switch de aynen if gibi daha çok sorgulama işlemi yapmak için kullanılır.Yani örneğimize bakalım:

#include
main(){
int x;
scanf("%d", &x);
switch(x ){
case 1: printf("x 1 mis");
case 2: printf("x 2 imis");
case 3: printf("x 3 imis");
}
}

Yukarıyı sırasıyla inceleyek.ilk 4 satırı zaten biliyonuz.Gelelim switc(x) dedimiz yere.Burada switche kontrol etmesi gereken
değişkenin adını soledik daha sonra { } parantezleri içerisine case1: deidk.case 1 x 1 e eşitse demektir.yani case burada
sorgulama yapan kişidr:)))bir çok koşul ifadesi kullancağımız zaman switche başvurailiriz.

sıra geldi while döngüsüne.Döngü nedir derseniz kendisine verilen işlemleri tekrarlatılması gereken sayıda tekrarlayan
yapılar diyebiliriz.Örneğimizi inceleyebilirz.

#include
main(){
int x=0;
while(x<4){
printf("amca");
x++;
}
}

yukarıda while(x<4) dedik yani bu demektirki eğer x 4 ten küçükse x değeri 4 e eşit olana kadar ekrana amca yazdır.Hımm.
Bu durumda x i 4 e şitleyecek bi yapı olması lazım.While döngüsünün içine baltığımızda x++; görüyoruz.x++ demektirki
x in değerini her seferinde 1 artır.yani döngü her başa sardığında yazdır sora x değerini 1 artır.Yukarıdaki programı çalıştırdığınızda
ekrana 4 tane amca yazısı gelcektir.

int deger, sayi;
deger=0;
while(deger<10){
sayi=deger+1;
printf("\n deger % dir",sayi);
}

arkadaşlar hatırlarsanız bundan once sizlere while dongüsünü if-else switch yapılarını anlarmıştım.Bu dersimizde ise for döngüsü
ve array yani dizilerden bahsedeceyim.
Şidi oncelikle örneğimizi inceleyelim:

int a;
for(a=0; a<4; a++){
printf("FermaN");
}

Şimdi sırasıyla bu kısmı inceleycek olursak: a=0; dedik ve ardındanda a<4 dediik.Bu şu demek oluyor.Arkadaşlar biz dögüyü
4 kez tekrarlatmak istiyoruz.Yani eğer döngünün 3 kez tekrarlanmasını istiyor olsaydık a=1; a<4; yada a=0; a<3; gibi ifadelerde
kullanabilirdik.a=0 buradaki başlangıç değeridir.yani a eşitlenmesi gerekn sayıya eşitlenene kadar a++ diyerek artırılabilir.Şimdi
for döngüsünü anlattığımıza göre döngüleri sonlandırmak için bir sonlandırma ifadesi kullanacağız.Bunun adı break.Bunu şu şekilde
kullancaz.Örneğimizi inceleyelim:

int a=1, b;
for(b=0; b<4; b++){
if(a==1){
break;
}
printf("FermaN");
}

Yukarıyı inceleyecek olursak for döngüsü içerisine birde if yapısı ekledik eğer a=1 ise break ile döngüyü sona erdirecek.Yani ekrana
FermaN çıktısı verilmeyecek.Bunun gibi birkaç program kontrol ifadeleri var ancak onları daha sonra göreceğiz.

Gelelim for döngüsünün çeşitlerine.Biz for döngüsü en sık yukardaki biçimde ve şu şekilde kullancağız.

for(;;){
printf("FermaN");
}

Yularıdaki döngümüzde for döngüsü içerisinde değişken v.s yok.Neden çünkü for döngüsü içerisindeki ;; sonsuz döngüyü beliritr.
Yani yukardaki kodları derlenirse ekrana sürekli FermaN çıktısı verilir.
for döngüsünde değişken döngü içersinde de tanımlanabilir.Örn:

for(int a=0; a<3; a++){
printf("FermaN");
}

gibi.Yukarıdaki örnekte değişken for döngüsü içindedir.

-Array(Dizi)-
int a[20];
Yukarıdaki şekilde a adında 20 tane tam sayı değişken tutabilen bir array tanıttık.Esasen bunlar a[1] a[2] şeklinde gitmesi lazımiken
ilk eleman[0] a atanıyor.Yani ikinci eleman a[1] de üçüncüsü ise a[2] de.Örneğin bu dizinin ilk elemanına bir değer atıyalım:
int a[0]=2;
Bu şekilde a[0] dizininin elemanını 2 yaptık.Şimdi basit bir program yapalım.Bizden üç tane tamsayı istesin ve bunlardan 2.dizideki
elemanı ekrana versin.

#include
main(){
int a[2];
for(int b=0; b<3; b++){
printf("\nBir sayi girin:");
scanf("%d",&a[b]);
}
printf("%d",a[1];
}

Şimdi yukarıdaki kodlarda aklınızı karıştıran yerler oldu sanırım ancak büyük ihtimalle. ve aklınızı en çok a[b]; bölümü karıştırdı.
Oncelikle int a[2] diyerek üç tamsayı tutabiliecek bir dizi tanıttık.daha sonra for dongüsü ile 3 tane tam sayı girdisi alacağımız için
döngüyü başlattık.sonra bu döngü içerisine scanf("%d",&a[b]); ifadesini koyduk.Neden???
Arkadaşlar bakın.örneğin 50 dizilik bir array tanıttığımız zaman her dizi için ayrı ayrı scanf kullanırsak olmaz.Adamın iflahı kesilir.
Bu yüzden bakın burayı iyi anlamaya çalışın:
b=0 diyerek a[b] dedik yani b=0 olduğundan a[b]=a[0] olacaktır.Yani doğal olarak ilk girdiğimiz tamsayı a[0] a atanacaktır.
Daha sonra döngü başa donecek b++ ile b=1 olacak ve ardından a[1] dizisine girdiğimiz değer yazılcaktır.Aynı işlem b=2 için de olcaktır.Yani
burada kısayol kullandık arkadaşlar.Bu ksımı anlamanız size yardımcı olacaktır.Yoksa aksi halde çok sayıda scanf ile
yakından arkadaşlığınız oluşacaktır:)

hatırlarsınız ki bundan onceki dersimizde dizileri görmüştük.Bu dersimizde ise stringleri gorebilirz demektir demektir bu.
Hatırlarsanız ders2 de değşkenlerden bahsetmiştik.int double float vs.vs.Ama bunların arasında char karşımıza çıkmadı.Aslında
double ve float da çıkmadı ancak ama olsun:)double ve float ondalıklı sayı için kullanılır.Neyse.char karakter harf tutmak için kullanılan
bir değişkendi.E biz kelime ve cümlelerle uğraşacamıza göre bunları harf taşıyan dizilere yani stringlerle halledecez.Şimdi
bi stringimiz olsun ve içerisinde FermaN yazsın.int B[6]; gibi bir şekilde dizimizi tanıtmış oluyorduk.Peki stringlerimizi nasıl tanıtacaz?_?
Tabiki aynı şekiin yandan yamiş şeklinde:)) C de Temeller-Devam
char B[6]; şu anda elimizde 6 tane harf tutabilen bir stringimiz var.Şimdi buna sırasıyla
harflerimizi yerleştirelim.

B[0]='F';
B[1]='e';
B[2]='r';
B[3]='m';
B[4]='a';
B[5]='N';
B[6]='\0';

Aslında yukarıya bakacak olursak atadığımız harfleri ' ' işaretleri arasına yerleştirdik.char değişkeninde bir değişkene değer atarken bunları
kullancaz.ilk sıraya B[0]=F; demiş olsaydık F adında bir değişken sanacak bizim c bu F yi.Bu yüzden.Birde son değere \0 değerini verdik.Bu nedemek arkadaşlar.Hatırlayın \n gibi bir operatörümüz vardı ve bu alt satıra geç demek oluyodu.Buradaki \0 ise
sona geldik string sona erdi dur bakalım.Demek oluyor ona göre:)Yukarıya bakarak bi string
için uzuuuuun uzun uraşacamızı gördünüz.tabiki olay boyle değil arkadaşlar biz.char A[]="FermaN"; desekdeolurdu.Burada stringin uzunluğunu belirtmedik ancak compiler bu olayı kendiliğinden çözecektir stringin uzunşuğunu hemencecik kavraycak ve
sona ise \0 operatörünü yapıştırcaktır.Burada dikkat edeceğiniz bir husus varki arkadaşlar oda "" işaretlerini kullanmış olmamız bu sefer.String belirlerken "" işaretlerini kullanıyoruz.Ancak harf yada karakter belirlerken ' ' işaretlerini kullanıyoruz.Mesela bizim bi stringmiz var
ve bu string üzerinde oynaşmalar yapabiliriz demektir.B[3]='\0'; dersek B[3] den sonraki kısım külliyen silinmiş olacaktır.Olay bu.Şimdi birde bu stringi printf ve scanf de kullanmaya.Bunu nasssı yapcaz diyecek olursanız?_?printf("%s", B); bu komut ekrana FermaN çıktısını vercektir.Burada pritfin içerisinde gördüğünüz %s i string okuturken kullancaz
Ama biz stringimiz belirli bir harfini olutmak istiyorsak aynen şoyle yapcaz;
printf("%c", A[B]); bu durumda ekrana r harfi gelecektir.Buradaki %c ise char türünde bir bir çıktı alacağımız belirtiyor.Yani burdada aklınız karışmasın arkadaşlar. scanf de ise olay printf ile aynıdır.scanf("%s", A); şimdi bundan once benim yapmış olduğum hatayı başıma kakınç eden bi arkadaş vardı adını vemicem.Burada scanf("%s",A); gibi bir ifade görünce yine "Aaaa yanlış yapmış yine bu adam" diyecektir ama bu sefer yanılacaktır.Çünkü stringlerimize
değer atarken & kullanmayız.Bunun sebebi ise pointerlerde annatacam.Aslında böyle uzun uzun printf ve scanf ile uğraşmak yerine kullanabileceğimiz fonksyonlarımız var.Ama bunları soylemeycem:p desem yalan olur.Tabikide soyleyecem. printf("%s", A); yerine puts(A); yazsakda aynı işi görecektir. scanf("%s", A); yerinede gets(A); yazsak aynı şey olurmu?_?Olmaz.gets ile stringe tüm satırı işletebilirsiniz ancak scanf aynı işi görmez. Mesela bi stringe "kral besiktas" gibi bi değer atıyacak olsak scanf sadece kral kısmını stringe atar.Niye?_?.Çünkü scanf her boşluktan sonrasını ayrı bi input sanar.gets(A) yazarsak.A stringine "kral besiktas" tümüyl atancaktır.
Sıra geldi fonksyon yazma olayınaaaaaa.Bu güne kadar kodlarımızı hep main() içerisine yazdık arkadaşlar.Ama bazen oluyorki aynı kodları dört beş kez yazmamız gerekiyor.
Hemde karışıklığı onlemk için bu kendi fonksyonlarımıızı yaabilirz.Şimdi örneğimizi inceleyelim:

#include
int x;

int topla(int a, int b);
int topla(int a, int b){
x=a+b;
}
main(){
topla(3,4);
printf("%d", x);
}

Evt yukardaki kodları compile ettiğimizde karşımıza 7 sonucu gelcektir.Yularıdan sanırım pek bişey anlamadınız.Şimdi sırasıyla bunları anlatalım;en başta bi tane int x; gördünüz.Bu ne kardeşim diyebilirsiniz.Bunu en sona bırakıyorum.Bunu scopelerle beraber anlatcam.topla adlı bir fonksyon belirledilk ve fonksyona iki tane tam sayı değişkenimizide verdik.a ve b.topla içerisine ise x=a+b dedik.Yani a ve b ye verilecek değeere göre x sonuclandırılacaktır.Peki buraya kadar herşey tamam. Fonksyonumuzu nasıl çağırdık? Tabikide main içerisine yazarak.main her zaman bizim kurtarıcımız olmuştur.Aslında main de başlı başına bir fonksyondur amma ve lakin
ana fonksyondur.Yani compiler ilk olarak main içerisindeki kodları işleme tabi tutacaktır.Neyse biz topla fonksyonumuza geri donelim.
Fonksyonlarımızı illakine int topla vs şeklindemi tanıtacaz.Tabiki hayır.Bunuda soa anlatcam.Şimdi topla fonlsyonu içerisindeki a ve be değişkenlerini herkes gördü sanırım.
topla(int a, int b) fonksyonunu çağırırken topla(3,4) dersek a=3 b=4 olur.Buradaki mantık bu.Beki şimdi ders başında scope dedim.Scope içerik anlamına getirilebilir.
Bakınız arkadaşlar.Şu kodları inceleyelim:

#include
int x;

int topla(int a, int b);
int topla(int a, int b){
x=a+b;
}
main(){
int a;
topla(3,4);
printf("%d", x);
scanf("%d", &a);
}

yukarıdaki kodlara iyi bakın arkadaşlar.int a iki tane!Alla Alla nasıl oluyor bu iş?Oluo.Çünkü ilk int a yani topla fonksyonunda tanımlamış olan a topla fonksyonunun scopesinde yani
içeriğinde tanımlı bir değişkendir.Diğer a değişkeni ise main fonksyonunun scopesinde tanımlıdır.Yani c bu iki a değişkeninide ayırt edebilir.Şimdi arkadaşlar hepiniz main fonklsyonu
içerisine bir tanede int x=3; şeklinde bi değişken tanımlamasını istiyorum.Bu değişkeni tanımladığınızda artık programın çıktısı 7 yerine 3 olacaktır.Çünkü burada program main içerisinde tanımlı olan x i okuyacaktır.Kodlarınızı şu şekilde değiştirin bide arkadaşlar;

#include
int x;
int topla(int a, int b);
int topla(int a, int b){
x=a+b;
printf("%d\n", x);
}
main(){
int x=4;
topla(3,5);
printf("%d", x);
scanf("%d", &a);
}

Bu durumda ekrana 8 ve 4 rakamları gelecektir.Çünkü main içerisindeki printf main içerisinde tanımlı x'i okuyacak topla içerisindeki printf ise toplada tanımlı x i okuyacaktır.
Yani bu scope olayını iyi anlayın arkadaşlar. Evet bu dersimiz bu kadar.Yani anlayıp anlamadığınızı belirtin arkadaşlar.Bakın anlamayıpta geçiştiriyosanız döverim:)Takılan arkadaşlar ister msn de ister forumda sorsun
ister mail atsın ister telefon etsin ister eve gelsin:)))))))Ama sorsun yani.Bu ders uzun mu oldu ne?Yorum bekliyom arkadaşlar bakın:)Bide bi odev verecem ama ne versem?

Buldum bunun içinde size random-randomize fonksyonunu anlatacam.Nedir bu random randomize?_?bu iki fonksyon sayesinde bilgisayar bize istediğimiz sayıda ve istediğimiz
aralıkta sayılar veririr.Örneğimizi inceleyelim.

#include
#include
#include

main(){
int i;
randomize();
for(i=0; i<5; i++)
printf("%d", random(25));
}

Yukarıdaki programı compile ettiğinizde ekrana 5 tane sayı gelecektir.Ve bu sayılar 0-25 aralığında olacaktır.0-25 aralığı nı random(25); fonksyonu ile belirtiriz.
Kaç sayı belirteceğimizi ise for döngüsü kullanarak.Dikkat ederseniz i=5 olana kadar random(25) yani 5 tane tam sayı belirtecek.Evt anlaşılmış olması lazım.Bide orada
yeni olarak görüyoruz.Çünkü bu, fonksyonların tanımlı olduğu kütüphane dosyaları.

Düzenleme tarihi:2004
Döküman tamamiyle bana aittir.

c nedir

C++ nesne yönelimli programlama tekniğinin uygulanabilmesi için C'nin genişletilmiş bir biçimidir. Nesne yönelimli programlama (object oriented programming) tekniği ve C++ B.Stroustroup tarafından geliştirilmiştir. Tasarım 70'li yılların ikinci yarısından başlanmış olsa da bütün dünyada yaygınlaşması ve kabul görmesi 80'li yılların sonlarına doğru mümküm olmuştur. Nesne yönelimli programlama tekniği (NYP) özellikle büyük kodların üstesinden gelebilmek amacıyla tasarlanmıştır. Tasarımı C++ üzerinde yapılmış olmasına karşın bugün pek çok yüksek seviyeli programlama dilleri bu tekniği desteklemektedir. C++ ve nesne yönelimli programlama tekniğinin en belirgin uygulama alanlarından birisi WINDOWS altında programlamadır. WINDOWS karmaşık ve yüksek yüksek seviyeli bir işletim sistemidir. WINDOWS altında program geliştirebilmek için uzun kodlar yazmak gerekir. Bu nedenle WINDOWS altında C ile değil C++ ile ve NYP tekniğini kullanarak program yazmak daha etkin bir çözümdür. NYP tekniğinin uygulanabilmesi için çalıştığımız sistemin kaynaklarının yeterince geniş olması gerekir. (Yani hızlı bir mikro işlemci, büyük RAM ve DISK ve iyi bir işletim sistemi)

C++'IN C'DEN FARKLILIKLARI

-NYPT İLE DOĞRUDAN İLİŞKİSİ OLMAYAN FARLILIKLARI VE FAZLALIKLARI




- SINIF YAPISI


İki düzeyde değerlendirilebilir;

1-) NYPT ile doğrudan ilişkisi olayan farkılılıklar ve fazlalıklar
2-) Sınıf yapısı

Sınıf (class) C'deki yapı (struct)'lara benzer bir veri yapısıdır. NYPT sınıflar kullanılarak program yazılması tekniğidir. Kursun %80'i sınıf yapısının yapısı ve kullanılması üzerine ayrılmıştır.

C++'IN NYPT İLE DOĞRUDAN İLİŞKİSİ OLMAYAN FARLILIKLARI VE FAZLALIKLARI

C++ derleyicileri C derleyicisini de içermek zorundadır. Yani C++ derleyicisi demek hem C hem de C++ derleyicisi demektir. Derleyici dosyanın uzantısına bakarak kodun C'de mi yoksa C++'ta mı yazılmış olduğuna karar verir. C'de ise uzantısı .C, C++'ta yazılmışsa uzantısı .CPP'dir.
1-) C++'ta yerel değişkenlerin bildirimleri blokların başında yapılmak zorunda değildir. Standart C'de yerel değişkenler blokların başında bildirilmek zorundadır. Yani küme parantezi açıldıktan sonra daha hiçbir fonksiyon çağırılmadan ve işlem yapılmadan yapılmalıdır. Bu tasarımın nedeni programcının bildirimin yerini kolay bulabilmesini sağlamaya yöneliktir. Oysa C++'ta yerel değişkenler bloğun herhangi bir yerinde bildirilebilir. Bir değişkenin kullanıma yakın bir bölgede bildirilmesi C++ tasarımcılarına göre daha okunabilirdir. (Değişken kavramı nesne isimlerini, struct, union ve enum isimlerini ve enum sabitlerini, typedef isimlerini içeren genel bir terimdir.) O halde C++'ta yerel değişkenin faaliyet alanı bildirim noktasından blok sonuna kadar olan bölgeyi kapsar. Ne olursa olsun bir blok içerisinde aynı isimli birden fazla değişken bildirimi yapılamaz.


C++’da for döngüsünün birinci kısmında bildirim yapılabilir. Örnek olarak:


for (int i = 0, j = 20; i + j < 50; ...) { }

Tabii while döngüsünün ve if deyiminin içerisinde bildirim yapılamaz.

#include
#define SIZE 100

void main(void)
{
for(int i = 0; i < SIZE; ++i)
printf("%d\n", i);
}

Böyle for döngüsünün içerisinde bildirilmiş değişkenlerin faaliyet alanları bildirildiği yerden for döngüsünün içinde bulunduğu bloğun sonuna kadar etkilidir. if, for, switch, while gibi deyimlerden sonra blok açılmamış olsa bile gizli bir bloğun açıldığı düşünülmelidir.

{
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
printf(%d\n”, j); /*geçerli*/
}
printf(“%d\n” ,i); /*geçerli*/
}
printf(“%d\n”, j); /*geçersiz*/
}

{
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
}
j = 10; /*geçersiz*/
i = 10; /*geçerli*/
}
}
2-) C++’ta // ile satır sonuna kadar yorumlama yapılabilir. C++’ta /* */ yorumlama biçiminin yanı sıra kolaylık olsun diye // ile satır sonuna kadar yorumlama biçimi de eklenmiştir. Son senelerde böyle bir yorumlama biçimi standart C’de de kullanılmaya başlanmıştır. Ancak ANSI C standartlarında tanımlı değildir. Taşınabilirlik bakımından bu yorumlama biçimini standart C’de kullanmak tavsiye edilmez.
3-) C++’ta çağırılan fonksiyon eğer çağıran fonksiyonun yukarısında tanımlanmamışsa fonksiyon prototipi zorunludur.
C ‘de bir fonksiyonun çağırıldığını gören derleyici fonksiyonun çağırılma noktasına kadar fonksiyonun tanımlamasıyla ya da prototipi ile karşılaşmamışsa geri dönüş değerini int olarak varsayar ve kod üretir. Dolayısıyla aşağıdaki örnek C’de geçerlidir.

void main(void)
{
int x;

x = fonk();
}

int fonk() /*Bu durum C’de sorun olmaz ama C++’ta error verir.*/
{

}

Oysa C++’ta derleyicinin çağırılma noktasına kadar fonksiyonun tanımlamasıyla ya da prototipiyle karşılaşması gerekir. Dolayısıyla yukarıdaki kod C++’ta error’dur. (NOT: C++ ve nesne yönelimli programlama tekniği bug oluşturabilecek kodlardan kaçınılması temeline dayandırılmıştır. Yani garanti yöntemler kullanılmalıdır. Bu sebeple C’deki pek çok uyarı C++’ta error’e dönüştürülmüştür.)

4-) C++’ta farklı parametre yapılarına sahip aynı isimli birden fazla fonksiyon tanımlanabilir.


void fonk(void)
{
}

void fonk(int x)
{
}

C’de ne olursa olsun aynı isimli birden fazla fonksiyon tanımlanamaz. Oysa C++’ta parametre yapısı sayıca ve/veya türce farklı olan aynı isimli birden fazla fonksiyon tanımlanabilir. Aynı isimli birden fazla fonksiyon varsa ve o fonksiyon çağırılmışsa gerçekte hangi fonksiyon çağırılmış olduğu çağırılma ifadesindeki parametre yapısı incelenerek belirlenir. Yani çağırılma ifadesindeki parametre sayısı ve türü hangisine uygunsa o çağırılmış olur. Geri dönüş değerinin farklı olması aynı isimli fonksiyon yazmak için yeterli değildir. Yani geri dönüş değerleri farklı fakat parametre yapısı aynı olan birden fazla fonksiyon tanımlanamaz.

#include

void fonk(int x)
{
printf("int = %d\n", x);
}

void fonk(long x)
{
printf("long = %ld\n", x);
}

void fonk(void)
{
printf("void\n");
}

void fonk(char *str)
{
puts(str);
}

void main(void)
{
fonk(); /*parametresi void olan fonksiyonu çağırır*/
fonk(10); /*parametresi int olan fonksiyonu çağırır*/
fonk(100L); /*parametresi long olan fonksiyonu çağırır*/
fonk(“merhaba”); /*parametresi karakter türünden gösterici olan fonksiyonu çağırır*/
}

İki Anlamlılık Hatası:


C++’ta pek çok durumda derleyicinin birden çok seçenek arasında karar verememesinden dolayı error durumuyla karşılaşılır. Bu tür hatalara iki anlamlılık hataları denir. Yukarıdaki örnekte fonk(3.2); gibi bir çağırma yapılırsa “Ambiguity between 'fonk(int)' and 'fonk(long)'” hatasını verir. Aynı isimli birden fazla fonksiyon arasında seçme işlemi ancak parametre sayıları çağılma ifadesine uygun birden fazla fonksiyon varsa gerçekleşir. Parametre sayısı çağırılma ifadesine uygun tek bir fonksiyon varsa bu durumda tür uyuşmasına bakılmaz. C’de olduğu gibi otomatik tür dönüştürmesi yapılarak o fonksiyon çağırılır.
C++ derleyicisi aynı sayıda parametrelere sahip birden fazla aynı isimli fonksiyonun bulunması durumunda çağırılma ifadesine tür bakımından uygun bir fonksiyon bulamazsa bu durum iki anlamlılık hatasına yol açar. Bu durumun 3 istisnası vardır:

· Fonksiyon char ya da short parametreleri ile çağırılmışsa char ya da short int parametreye sahip bir fonksiyon yok ancak int parametreye sahip bir fonksiyon varsa int parametreye sahip olan fonksiyon çağırılır.
· Fonksiyon float parametreyle çağırılmışsa ancak float parametreye sahip bir fonksiyon yok double parametreye sahip bir fonksiyon tanımlanmışsa bu durumda double parametreye sahip olan fonksiyon çağırılır.
· Fonksiyon aynı türden const olmayan bir ifadeyle çağırılmışsa ancak aynı türden const parametreye sahip bir fonksiyon tanımlanmışsa tür uyuşumunun sağlandığı kabul edilir ve const parametreye sahip olan fonksiyon çağırılır.

C’de ve C++’ta tanımlanan ve çağırılan bir fonksiyon ismi .obj modül içerisine yazılmak zorundadır. .obj modül standardına göre aynı isimli birden çok fonksiyon modül içerisine yazılamaz. Standart C derleyicileri fonksiyon isimlerinin başına bir _ ekleyerek obj modülün içerisine yazarlar. Oysa C++ derleyicileri fonksiyon isimlerini parametre türleriyle kombine ederek obj modül içerisine yazarlar. Bu durumda C++’ta aynı isimli farklı parametrelere sahip fonksiyonlar sanki farklı isimlere sahiplermiş gibi obj modüle yazılırlar.
5-) extern “C” ve extern “C++” bildirimleri ile C++’ta normal olarak bütün standart C fonksiyonları çağırılabilir. Standart C fonksiyonları .LIB dosyalarının içerisine başında “_” bulunarak yani standart C kurallarıyla yazılmışlardır. Oysa bu fonksiyonların C++’tan çağırılmasıyla bir uyumsuzluk ortaya çıkar. Çünkü C++ derleyicisi çağırılan fonksiyonu .OBJ modül içerisine başına “_” koyarak değil parametre türleriyle kombine ederek yani C++ kurallarıyla yazar. extern “C” bildirimi bir fonksiyonun prototipinin önüne ya da bir fonksiyonun tanımlamasının önüne getirilirse Örneğin;

extern “C” double sqrt(double);

veya

extern “C” void fonk(void)
{
.........
}

derleyici bu fonksiyonu obj modül içerisine C kurallarıyla yani başına “_” koyarak yazar. Böylece C’de yazılmış olan C++’tan kullanılması mümkün olur. Bir grup fonksiyon yazım kolaylığı sağlamak için extern “C” bloğu içine alınabilir.

extern “C” {
void fonk(void);
void sample(void);
....
}

Bloğun içerisinde başka bildirimler ve kodlar bulunabilir. Ancak derleyici yalnızca bu bloğun içerisindeki fonksiyonlarla ilgilenir. Bu durumda standart C başlık dosyalarının içerisinde fonksiyonların extern “C” bildirimiyle prototipleri yazılmış olması gerekir. Aynı dosya hem C hem C++’ta include edilip kullanılabildiğine göre ve extern “C” bildirimi sadece C++ için geçerliyse bir problem ortaya çıkmaz mı? Bu problem önceden tanımlanmış cplusplus sembolik sabitiyle çözümlenmiştir:

#ifdef cplusplus
extern ”C” {
#endif
..... Fonksiyon prototipleri


.....
.....
.....
.....
.....
#ifdef cplusplus
}
#endif

Bir de extern “C++” bildirimi vardır. Bu bildirim fonksiyon isimlerinin C++ kurallarına göre obj modülün içerisine yazılacağını anlatır. Zaten fonksiyonlar default olarak bu kurala göre yazılırlar. Bu bildirim ileriye doğru uyumu sağlamak için düşünülmüştür. Şu anda bir kullanım gerekçesi yoktur.
6-) C++’ta dinamik bellek yönetimi new ve delete isimli iki operatörle yapılır. Mademki C++ içerisinde bütün standart C fonksiyonları kullanılabiliyor, o halde dinamik bellek yönetimi malloc, calloc, realloc ve free fonksiyonlarıyla yapılabilir. Ancak bu fonksiyonlar nesne yönelimli programlama tekniğini uygulayabilmek için tasarlanmamıştır. Bu yüzden C++’ta yeni bir teknik kullanılmaktadır. C++’ta dinamik olarak tahsis edilme potansiyelindeki boş bölgelere free store denilmektedir. (standart C’de heap denir).



new OPERATÖRÜ

Genel biçimi:

new [<[uzunluk]>]

new int
new char
new double [10]
new float[n]
new char[strlen(s) + 1]

Eğer köşeli parantez olmadan sadece tür ismi ile tahsisat yapılırsa o türden 1 elemanlık yer tahsis edilmiş olur. Örneğin;

new int à1 int’lik yer tahsis edilmiştir.

Eğer köşeli parantez içerisine ifade yazılarak kullanılırsa bu durumda o ifade ile belirtilen sayıda elemanlık alan tahsis edilir. new operatörü türü belirli bir alan tahsis eder. Yani new operatörüyle elde edilen adresin tür bileşeni çağırılma ifadesindeki tür ile aynı olur.

int *p;
p = new int;



Burada sizeof(int) kadar byte tahsis ediliyor ve tahsis edilen alanın başlangıç adresi elde ediliyor. Bu adres int türündendir.

char *p;
p = new int [10]; /* C++’ta hatadır. */
p = (char *)new int[10]; /* Hata değil. */

/*----------new1.cpp---------*/

#include
#include

void main(void)
{
char *p;

p = new char[30];
gets(p);
puts(p);
}

/*------------------------------*/

new bir operatördür. Ancak derleyici bu operatör kullanıldığında dinamik tahsisat işleminin yapılmasını sağlamak için dinamik tahsisat yapan bir fonksiyonun çağırma kodunu amaç koda ekler. Yani new bir operatör olmasına karşın tahsisat işlemi yerleştirilen bu fonksiyon sayesinde programın çalışma zamanı sırasında yapılmaktadır. Bu operatör öncelik tablosunun ikinci düzeyinde bulunmaktadır. Örneğin:

new int + n

gibi bir işlem geçerlidir. İşlemler:

İşlem 1 : new int
İşlem 2 : İşlem 1 + n

new operatörü tahsisat işlemini yapamazsa 0 değerini (NULL gösterici) üretir.

/*-------freestor.cpp------*/
/*free store alanının hesaplanması*/
#include

#define BLOCKSIZE 1024

void main(void)
{
long size = 0;
char *p;

for(;{
p = new char[BLOCKSIZE];
if(p == NULL)
break;
size += BLOCKSIZE;
}
printf("Free store size = %ld\n", size);
}
/*---------------------------*/

Köşeli parantez içerisine yazılan ifade sabit ifadesi olmak zorunda değildir.

/*-----------new2.cpp---------*/
/* Tam olarak ad soyad uzunluğu kadar bellek tahsis eden fonksiyonun kullanılışı */
#include
#include

char *getname(void)
{
char *p;
char buf[80];

printf("Adı Soyadı:”);
gets(buf);
p = new char[strlen(buf) + 1)];
if(p == NULL){
printf("Cannot allocate memory..\n");
exit(1);
}
strcpy(p, buf);
return p;
}

void main(void)
{
char *p;

p = getname();
puts(p);
}
/*--------------------------------*/

delete OPERATÖRÜ

delete operatörü new operatörüyle tahsis edilmiş olan blokları serbest bırakmak için kullanılır. Genel biçimi;

delete operatörü new operatörüyle tahsis edilmiş olan blokları serbest bırakmak için kullanılır. Genel biçimi;

1. delete p;
2. delete [ ] p;

Eğer tahsisat tek parça olarak yapılmışsa yani köşeli parantez kullanılmadan yapılmışsa silme işlemi köşeli parantez kullanılmadan yapılmalıdır. Örneğin:

int *p;
p = new int;
delete p;

Eğer tahsisat işlemi birden fazla eleman için yapılmışsa yani köşeli parantez kullanılarak yapılmışsa serbest bırakma işleminde de köşeli parantez kullanılmalıdır. Örneğin:

int *p;
p = new int[n];
delete [ ] p;

Burada köşeli parantez içerisine bir şey yazılmaz. delete operatörü unary prefix bir operatördür ve öncelik tablosunun ikinci düzeyinde bulunur.

delete p + 1; /*Hatalı*/
delete (p + 1);/*Doğru*/

delete operatörünün operandı daha önce tahsis edilmiş olan bloğun başlangıç adresi olmalıdır. Değilse beklenmeyen sonuçlar ortaya çıkabilir. Tabii derleyici delete operatörüne karşılık amaç koda (object module’e) free gibi tahsis edilmiş bloğu serbest bırakan bir fonksiyon kodu yerleştirmektedir. new delete operatörlerinin tahsisat işlemlerinde kullandığı fonksiyon maloc, calloc, free fonksiyonları olmak zorunda değildir. Bu iki grup fonksiyon farklı tahsisat tabloları kullanıyor olabilir. Bu nedenle new delete operatörleriyle malloc, calloc, free gibi standart C fonksiyonlarını özel bir durum yoksa birlikte kullanmamak gerekir. Çünkü bir grup tarafından tahsis edilen alan diğer grup tarafından tahsis edilmemiş gibi gözükebilir.
Görüldüğü gibi C++’ta realloc fonksiyonun karşılığı bir operatör yoktur. Ancak böyle bir fonksiyon yazılabilir.

/*------------realloc.cpp---------------*/
void *Realloc(void *ptr, size_t newsize, size_t oldsize) /*size_t àunsigned int*/
{
void temp;

temp = new char [newsize];
memcpy(temp, ptr, oldsize);
delete [] ptr;
return temp;
}
/*----------------------------------------*/


Kullanımı;

p = new char [10]; /* 10 * sizeof(char) kadar bellek tahsis edildi */
p = Realloc(p, 20, 10); /* Tahsis edilmiş alan 20 * sizeof(char)’e büyütüldü */

set_new_handler FONKSİYONU:

Normal olarak new oparetörü başarısızlıkla sonuçlandığında 0 adresine geri döner ve bu adresin test edilmesi gerekir. Ancak her new kullanımında bu adresin test edilmesi yerine daha etkin bir yöntem kullanılmaktadır. new operatörü başarısız olduğunda set_new_handler fonksiyonu ile belirlenen fonksiyonu çağırmaktadır. Böylece her defasında kontrol yapılmasına gerek kalmaz.

set_new_handler(void (*ptr)(void));

set_new_handler’a parametre olarak geri dönüş değeri void parametresi void olan bir fonksiyonun adresi verilir. Artık başarısızlık durumunda bu fonksiyon çağırılacaktır. new operatörü başarısızlık durumunda belirlenen fonksiyonu çağırır ve bu fonksiyon çağırıldıktan sonra tekrar tahsisat işlemini yapar. Yine başarısız olursa tekrar fonksiyonu çağırır ve bu böyle devam eder. Yani aşağıdaki algoritmadaki gibi çalışır:

for(; {
if(boşyer var mı)
return boşyer;
else
set_new_handler();
}

/*-----------snhandle.cpp---------------*/
#include
#include
#include

long size = 0;

void myhandler(void)
{
printf("Free store size=%ld\n", size);
exit(1);
}
void main(void)
{
void *ptr;
void *oldhandler;

oldhandler = set_new_handler(myhandler);
for(;{
ptr = new char [1024];
size += 1024;
}
}
set_new_handler(oldhandle); /*handler eski haline dönüştürüldü*/
/*------------------------------------------*/

7+Bir adresin farklı türden bir göstericiye atanması ve adres olmayan bir bilginin bir göstericiye atanması durumu uyarı değil error olarak değerlendirilir.
Adres işlemlerinde tür uyuşmazlıkları C++’ta error olarak değerlendirilir. Oysa standart C derleyicileri böyle durumlarda en fazla uyarı verirler. Ancak void göstericiye herhangi bir türden adres atanabilir. Fakat void bir adresin herhangi bir göstericiye atanması error olarak değerlendirilir (bu durum C’de en fazla uyarı olarak değerlendirilir). Tabii tür dönüştürme operatörüyle her tür her türe atanabilir.

/*----------fark7.cpp----------*/
void main(void)
{
int s[100];
char *t;

t = s; /* “Cannot convert 'int *' to 'char *'” hatasını verir */
t = (char *)s; /* Hata vermez */
}
/*--------------------------------*/
8-) const bildirimi ile yaratılmış bir değişken sabit ifadesi gibi işlem görür. C++’ta const bir değişken için yine bellekte yer ayrılır. Ancak const değişken kullanıldığında derleyici eğer const değişkene ilk değer sabit ifadesiyle verildiyse derleyici doğrudan o sabit ifadesini kullanır. Tabii const değişkene verilen ilk değer sabit ifadesi değilse bu const’a değişken kullanıldığında derleyici doğrudan bir sayı yerleştiremez, const değişkenin kendisini yerleştirir.

const int MAX = a + 100;
const int MIN = 1;
y = MAX; /* Burada bir sayı yazamaz */
y = MIN; /* Burada MIN yerine 1 yazılabilir */
const int SIZE = 10;
int a[SIZE]; /* C++’ta geçerli C’de geçerli değil */

const değişken için yine de bellekte yer ayrılır. Bu durumda const değişkenin adresi alınabilir. Bu yolla const deişkenin içeriği de değiştirilebilir. Tabii bu değiştirme programın çalışma zamanı içerisinde olduğundan sonucu değiştirmez.

/*----------fark8.cpp------------*/
#include

void main(void)
{
const int SIZE = 10;
int *p;

p = (int *)&SIZE;
*p = 20;
printf("%d\n", SIZE);
}
/*--------------------------------*/
9-) C++’ta statik ömürlü değişkenlere sabit ifadesiyle ilk değer verme zorunluluğu yoktur. Global değişkenler ve statik yerel değişkenler gibi statik ömürlü değişkenlere ilk değer C’de sabit ifadesiyle verilmek zorundadır. Çünkü statik ömürlü değişkenler amaç kod içerisine ilk değerleriyle yazılırlar. Exe dosyasının içerisinde yer alırlar. Bunun mümkün olabilmesi için verilen ilk değerlerin derleme aşamasında belirlenmiş olması gerekir. Derleme aşamasında tespit edilmesi için ifadenin sabit ifadesi olması gerekir. Oysa C++’ta statik ömürlü değişkenlere her türden sıradan bir ifadeyle ilk değer verilebilir. Bu değişkenler 0 ilk değeriyle amaç koda yazılırlar. Programın çalışma zamanı sırasında ve main fonksiyonundan önce ilk değerini alırlar.

10-) Parametre değişkenlerinin default değerler alması (default function arguments). C++’ta fonksiyon çağırılırken bir parametre belirtilmemişse ona ilişkin parametre değişkeni default bir değer alabilir. Böyle bir durum C’de yoktur. Bir parametre değişkeninin default değer alması durumu fonksiyon tanımlanırken ya da prototip bildiriminde parametre değişkeninden sonra eşittir operatörüyle belirtilmelidir.

/*---------fark10.cpp----------*/
#include

void fonk(int x = 10, int y = 20)
{
printf("x = %d y = %d\n", x ,y);
}

void main(void)
{
fonk(100, 200); /* x = 100 y = 200 */
fonk(100); /* x = 100 y = 20 */
fonk(); /* x = 10 y = 20 */
}
/*--------------------------------*/

Bir parametre değişkeni default değer almışsa onun sağında bulunanların hepsi default değerler almak zorundadır.

void fonk(int x = 10, int y) /* Hata verir */
{
}

void fonk(int x, int y = 20) /* Hata vermez */
{
}

Default değer almamış olan bütün parametre değişkenleri için çağırılma ifadesinde parametre yazılmak zorundadır. Default değer alan parametre değişkenlerine sahip fonksiyonlarla aynı isimli başka fonksiyonların birlikte bulunması durumunda iki anlamlılık hataları oluşabilir. İki anlamlılık hataları fonksiyonların tanımlanması sonucunda değil çağırılması sonucunda ortaya çıkmaktadır.

/* İki anlamlılık hatası örneği */
#include

void fonk(int x, int y = 20)
{
printf("%d %d\n", x, y);
}

void fonk(int x)
{
printf("%d\n", x);
}

void main(void)
{
fonk(100, 200); /* Hata vermez */
fonk(100); /* İki anlamlılık hatası verir */
}
/*------------------------------------------*/

Bir gösterici parametresi de default değer alabilir.

/* Göstericiye default değer */
#include

void message(const char *p = "Success")
{
puts(p);
}

void main(void)
{
char *p = "Ali";

message(p);
message();
}
/*-------------------------------------------*/

Default Parametre Değişkenlerine Sahip Fonksiyonların Kullanılma Nedenleri:


Çok sayıda parametrelere sahip fonksiyonlar söz konusu ise ve bu parametre değişkenlerinin belli bölümüne çağırma sırasında aynı değerler atanıyorsa default parametre değişkenlerinin kullanılması büyük bir yazım kolaylığı sağlar. Fazla sayıda parametrenin yazılmaması hem programcının iş yükünü azaltır, hem de okunabilirliği arttırır.
#include
#include
void *myitoa(int n, char *str, int base = 10)
{
return itoa(n, str, base);
}

void main(void)
{
char s[100];

myitoa(123, s);
puts(s);
}
Default değer alan parametre değişkeni kullanılırken dikkat etmek gerekir. Bir fonksiyon % 90 aynı parametre değerleriyle çağırılıyorsa default parametre değişkeni kullanılmalıdır. “Hiçbir değer almayacağına bari şu değeri alsın” fikriyle kullanılmamalıdır. Böylesi kullanımlar kodu inceleyen kişiyi yanıltırlar. Bazen parametre değişkenine verilen default değerin özel bir anlamı olmaz. Bu default değer fonksiyonun default parametreyle çağırılıp çağırılmadını tespit etmek amacıyla kullanılır. Gerçek default değerler fonksiyonun içerisinde ve bir dizi işlemlerle elde edilir. Örneğin

#define DEFAULT_CALL (-1)

void writefile(void *ptr, unsigned size, long offset = DEFAULT_CALL)
{
if(offset != DEFAULT_CALL)
fseek(fp, offset, SEEK_SET);
fwrite(ptr, 1, size, fp);
}

void main(void)
{
double x = 10.2;

writefile(&x, sizeof(double));
}

Default Değer Alan Parametre Değişkenlerine Sahip Fonksiyonların Prototipleri:

Böyle fonksiyonların prototiplerinde default parametre değerleri belirtilmelidir. Prototip yazma işlemi değişken isimlerini kullanarak ya da kullanmayarak yapılabilir. Örneğin aşağıdaki iki prototip de geçerlidir.

void sample(int = 10, int = 20);
void sample(int a = 10, int b = 20);

Prototipi yazılan fonksiyon aynı modül içerisinde tanımlanıyorsa (yani kütüphane içerisinde değilse) tanımlama sırasında bir daha bu default değerler yazılamaz. Yani default değerler ya prototipte ya da tanımlama sırasında belirtilmek zorundadır. Her ikisinde birden belirtilemezler. Tavsiye edilen kullanım prototipte belirtilmesi, tanımlama da belirtilmemesidir.

void sample(int x = 10, int y = 20);

void sample(int x =10, int y = 20) /* Hata verir */
{
}

void sample(int x, int y) /* Hata vermez */
{
}
11-) C++’ta göstericilere benzeyen ve ismine referans denilen ayrı bir tür vardır.



REFERANS TÜRÜNDEN BİR GÖSTERİCİNİN TANIMLANMASI


Genel biçimi;

& =

Örnek:

int a = 10;
int &b = a;

double x;
..........
double &y = x;

Bir referans ilk değer verilerek tanımlanmak zorundadır. Örneğin:

int &r; /* hata */
double &r = 10.2; /* hata */

Referansa verilen ilk değer aynı türden bir nesne olmak zorundadır.

double x = 10 ;
int &r = x; /* Hata. Farklı türden bir nesneyle ilk değer verilmiş. */
int &r = a; /* Okunuşu: r int türünden bir referanstır */

Referanslar bir çeşit düzeyi yüksek göstericidir. Referansların içerisinde adres bilgisi bulunur. Derleyici bir referans tanımlandığında ilk değer olarak verilen nesnenin adresini referansın içerisine yerleştirir. Referansları iyi anlayabilmek için onların eşdeğer gösterici karşılıklarını düşünmek gerekir. Eş değer gösterici karşılığı referans yerine gösterici kullanıldığında elde edilecek eş değer kod anlamına gelir.

int a = 10;
int &b = a;

Eşdeğer karşılığı:

int a = 10;
int *b = &a;

Bir referans ilk değer verildikten sonra kullanıldığında artık referans içerisindeki adres değil referans içerisindeki adreste bulunan bilgi temsil edilir.






/*----------fark11.cpp--------------*/

#include

#if 1

void main(void) /* referans kullanımı */
{
int a = 10;
int &b = a;

b = 50;
printf("%d %d\n", b, a);
}

#endif

#if 0

void main(void) /* referansın gösterici karşılığı */
{
int a = 10;
int *b = &a;

*b = 50;
printf("%d %d\n", *b, a);
}

#endif
/*-------------------------------------*/

int a = 10;
int &b = &a; /* Hata: &a int türünden değil adres türündendir */




Referansların Fonksiyon Parametresi Olarak Kullanılması:

Referanslar fonksiyon parametresi olarak kullanılabilirler. Madem ki bir referans aynı türden bir nesneyle ilk değer verilerek tanımlanmak zorundadır, o halde parametresi referans olan fonksiyonlar aynı türden bir nesnenin kendisiyle çağırılmak zorundadır.

/* fonksiyon parametresi olan referans örneği */

#include

#if 1 /* parametresi referans */
void fonk(int &a)
{
a = 20;
}

void main(void)
{
int x = 10;

fonk(x);
printf("%d\n", x);
}
#endif

#if 0 /* gösterici karşılığı */
void fonk(int *a)
{
*a = 20;
}

void main(void)
{
int x = 10;

fonk(&x);
printf("%d\n", x);
}
#endif
/*------------------------------------------------------------*/

Bir C programında fonk(a) gibi bir çağırma işlemiyle a değiştirilemez. Oysa C++’ta böyle bir çağırma fonksiyonun parametre değişkeni bir referans ise a parametresini değiştirebilir. Klasik bir C bakış açısıyla parametre olan a’nın değiştirilmeyeceği sanılabilir. Okunabilirliği kuvvetlendirmek için eğer parametreyi değiştirecek bir fonksiyon tasarlanacaksa bunun için referans değil gösterici kullanılmalıdır. Fonksiyonun parametre değişkeni referans ise derleyici tarafından otomatik olarak yapılan bir adres aktarımı söz konusudur.

Referans uygulaması
Gösterici eşdeğeri
int a = 10;
int &r1 = a;
int &r2 = r1;

r2 = 20;
printf(“%d\n”, r1);
int a = 10;
int *r1 = &a;
int *r2 = r1;

*r2 = 20;
printf(“%d\n”, *r1);

/*-----referans.cpp-----*/
#include

#if 1 /* referans örneği */

void main(void)
{
int a = 10;
int &a1 = a;
int &a2 = a1;

a2 = 20;
printf("%d\n", a1);
}

#endif

#if 0 /*gösterici eşdeğeri */

void main(void)
{
int a = 10;
int *a1 = &a;
int *a2 = a1;

*a2 = 20;
printf("%d\n", *a1);
}

#endif
/*-------------------------*/

/*-----referan1.cpp-----*/
#include

void main(void)
{
int a = 10;
int &b = a;


printf("%p %p\n", &a, &b);
}
/*--------------------------*/

Bir referans & operatörüyle adres alma işlemine sokulabilir. Bu durumda elde edilen değer referans içerisinde bulunan adreste bulunan nesnenin adresidir. Bu da referans içerisindeki adresle aynı olmak zorundadır. Bir referansın da bir adresi vardır. Ama o adres değeri geçerli bir ifade ile elde edilemez. r bir referans olmak üzere & &r; ifadesi geçerli değildir. Çünkü bu ifadenin eşdeğer gösterici karşılığı & &*p;’dir ve &*p bir nesne değildir.



Yapı Değişkenlerinin Referans Yoluyla Fonksiyonlara Geçirilmesi:


Bir yapı değişkeninin fonksiyona aktarılmasında doğru teknik yapı değişkeninin adresinin fonksiyona geçirilmesidir. Yani fonksiyon yapı değişkeninin adresiyle çağırılır, fonksiyonun parametre değişkeni o yapı türünden bir gösterici olur. Fonksiyonun içerisinde elemana ok(->) operatörüyle erişilir. Ancak C++’ta aynı etkinlikte olmak üzere referansla aktarım da söz konusudur. Yani fonksiyon yapı değişkeninin kendisiyle çağırılır. Fonksiyonun parametre değişkeni o yapı türünden bir referans olur. Fonksiyon içeriisnde elemana nokta operatörüyle erişilir.

/*----------referan2.cpp-------------*/
#include

struct PERSON {
char *name;
int no;
};

void disp(struct PERSON &r)
{
printf("%s %d\n", r.name, r.no);
}

void main(void)
{
struct PERSON per = {"Ali Serçe", 123};

disp(per);
}
/*--------------------------------------*/

Yapıların referans ya da gösterici yoluyla fonksiyonlara aktarılması tamamen eşdeğer kullanımlardır.



const Referanslar:


Bir referans da const olarak tanımlanabilir.

Referans örneği
Gösterici eşdeğeri
int a = 10;
const int &b = a;

b = 20; /* Hata */
int a = 10;
const int *p = &a;

*p = 20; /* Hata */

const bir referans, gösterdiği yer const olan const bir göstericiye eşdeğerdir. Yani böyle referanslar sol tarafa değeri olarak kullanılamaz. Çünkü referans içerisinde bulunan adresteki bilgi const yapılmıştır. Const referanslar da okunabilirliği arttırmak amacıyla fonksiyon parametresi olarak kullanılırlar.

void disp(const struct PERSON &r);
Fonksiyonun referans olan parametresi de default argüman alabilir.

int x;

void fonk(int &a = x) /*fonksiyonun referans olan parametresi default değer almış*/
{
...
}

char &a = ”Ali”; /* Doğru bir kullanımdır */

Fonksiyonun Geri Dönüş Değerinin Referans Olma Durumu:

return ifadesiyle geri dönüş değerinin oluşturulması aslında derleyici tarafından tahsis edilen geçici bir bölgeye yapılan atama işlemidir. Yani return ifadesi önce geçici bir bölgeye yerleştirilir, sonra oradan alınarak kullanılır. Fonksiyonun geri dönüş değerinin türü bu geçici bölgenin türüdür. Bir fonksiyonun geri dönüş değeri referans olabilir. Bu durumda fonksiyonun geri dönüş değerine ilişkin geçici bölge referans türündendir. Bir referansa bir nesneyle ilk değer verileceğine göre böyle fonksiyonların return ifadelerinin de nesne olması gerekir.


Gösterici eşdeğeri
Referans örneği
/*-----referan3.cpp-----*/
#include

int a = 10;

int *fonk(void)
{
return &a;
}

void main(void)
{
*fonk() = 20;
printf("%d\n", a);
}
/*------referan4.cpp-----*/
#include

int a = 10;

int &fonk(void)
{
return a;
}

void main(void)
{
fonk() = 20;
printf("%d\n", a);
}


Artık bu fonksiyon kullanıldığında referans kullanılıyor gibi işlem göreceğinden return ifadesindeki nesne anlaşılır. Böyle fonksiyonların geri dönüş değeri nesne belirtir ve sol taraf değeri olarak kullanılabilir. Özetle referansa geri dönen bir fonksiyonun geri dönüş değeri kullanıldığında return ifadesindeki nesnenin kullanıldığı anlaşılır.

Bir Referansa Farklı Bir Türden Bir Nesneyle İlk Değer Verilmesi Durumu:

Böyle bir durumda önce referansla aynı türden geçici bir değişken yaratılır. Verilen ilk değeri bu geçici değişkene atar, tabii otomatik tür dönüştürülmesi olur ve yaratılan bu geçici bölgenin adresi referansa aktarılır.

/*-----referan5.cpp-----*/
#include

void main(void)
{ /* Eşdeğeri */
double x = 3.2; /* double x =3.2; */
int &r = x; /* int temp = x; */
/* int &r = temp; */
r = 5;
printf("%f\n", x);
}
/*--------------------------*/

Tabii böylesi bir durumda derleyiciler bir uyarıyla durumu bildirirler.


Bir Referansa Sabitle İlk Değer Verilmesi Durumu:

Bir referansa bir sağ taraf değeriyle de ilk değer verilebilir. Bu durumda ilk değer olarak verilen sağ taraf değeri derleyici tarafından oluşturulan geçici bir bölgenin içerisine aktarılır. Geçici bölgenin adresi de referansa yerleştirilir.


Böyle iki problemli ilk değer verme durumlarından da kaçınmak gerekir. Her iki durumda da derleyici uyarı mesajı verecektir.



Göstericilerle Referanslar Arasındaki Benzerlikler ve Farklılıklar:
Göstericiler de referanslar da adres tutan nesnelerdir.
Referansın içerisindeki adres bir daha değiştirilemez ama göstericinin içerisindeki adres değiştirilebilir.
Diziler türü ne olursa olsun, referans yoluyla referanslara geçirilemezler. Çünkü dizi elemanlarına erişmek için adres arttırımı yapmak gerekir.
Referanslar tek bir elemanı fonksiyona geçirmek için kullanılabilirler.
Kaydol: Yorumlar (Atom)