adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 23:33:00 +03:00
Code Issues Projects Releases Wiki Activity

some updates turkish translation for latest updates of forked repo

Browse Source
This commit is contained in:
Haydar Kulekci 2013-08-19 14:41:44 +03:00
parent dbf05283fc
commit f6b7d0b2c0
1 changed files with 271 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

475
tr-tr/c-tr.html.markdown
View File

@ -24,11 +24,16 @@ anlarsanız sizi isteğiniz yere götürecektir.
Çoklu satırlı yorumlar bu şekilde görünür. Çoklu satırlı yorumlar bu şekilde görünür.
*/ */
// #include ile header dosyalarınız dahil edin. // C Standart kütüphanelerini uygulamanıza #include<ornek.h> ile
// dahil edebilirsiniz.
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
// Kendi başlık(header) dosyalarınız dahil etmek için "çift tırnak"
// kullanmalısınız.
#include "my_header.h"
// Fonksiyonlarınızı bir .h dosyasında ya da c dosyanızın üst tarafta // Fonksiyonlarınızı bir .h dosyasında ya da c dosyanızın üst tarafta
// tanımlayın. // tanımlayın.
@ -39,265 +44,317 @@ void function_2();
// integer değer döner // integer değer döner
int main() { int main() {
// çıktıları yazdırmak için printf kullanılır, "print formatted" // çıktıları yazdırmak için printf kullanılır, "print formatted"
// %d bir sayı tipidir, \n yeni satır karakteridir // %d bir sayı tipidir, \n yeni satır karakteridir
printf("%d\n", 0); // => 0 karakteri yazdırılır. printf("%d\n", 0); // => 0 karakteri yazdırılır.
// Tüm ifadeler noktalı virgül ile bitmelidir. // Tüm ifadeler noktalı virgül ile bitmelidir.
/////////////////////////////////////// ///////////////////////////////////////
// Tipler // Tipler
/////////////////////////////////////// ///////////////////////////////////////
// Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken // Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken
// tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler. // tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler.
// int değişken tipi 4 byte boyutundadır. // int değişken tipi 4 byte boyutundadır.
int x_int = 0; int x_int = 0;
// short değişken tipi genellikle 2 byte boyutundadır. // short değişken tipi genellikle 2 byte boyutundadır.
short x_short = 0; short x_short = 0;
// char tipi 1 byte boyutunu garanti eder. // char tipi 1 byte boyutunu garanti eder.
char x_char = 0; char x_char = 0;
char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır. char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır.
// long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler. // long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler.
long x_long = 0; long x_long = 0;
long long x_long_long = 0; long long x_long_long = 0;
// float tipi 32-bit kayan noktalı sayı boyutundadır. // float tipi 32-bit kayan noktalı sayı boyutundadır.
float x_float = 0.0; float x_float = 0.0;
// double değişken tipi 64-bit kayan noktalı yazı tipindedir. // double değişken tipi 64-bit kayan noktalı yazı tipindedir.
double x_double = 0.0; double x_double = 0.0;
// Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer // Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer
// olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum // olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum
// değeri işaretli bir sayının maksimum değeriden büyük olur. // değeri işaretli bir sayının maksimum değeriden büyük olur.
unsigned char ux_char; unsigned char ux_char;
unsigned short ux_short; unsigned short ux_short;
unsigned int ux_int; unsigned int ux_int;
unsigned long long ux_long_long; unsigned long long ux_long_long;
// Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler // Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler
// makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte // makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte
// cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir // cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir
// şekilde ifade edilebilir // şekilde ifade edilebilir
// Örneğin, // Örneğin,
printf("%lu\n", sizeof(int)); // => 4 (on machines with 4-byte words) printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words)
// Diziler somut bir boyut ile oluşturulmalıdır. // If the argument of the `sizeof` operator an expression, then its argument
char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar // is not evaluated (except VLAs (see below)).
int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar // The value it yields in this case is a compile-time constant.
// (4-byte bir word varsayılır) int a = 1;
size_t size = sizeof(a++); // a++ is not evaluated
printf("sizeof(a++) = %zu where a = %d\n", size, a);
// prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture)
// Şu şekilde bir diziyi 0 ile oluşturabilirsiniz: // Diziler somut bir boyut ile oluşturulmalıdır.
char my_array[20] = {0}; char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar
// (4-byte bir word varsayılır)
// Dizinin elemanlarını indexlemek diğer diller gibidir, veya // Şu şekilde bir diziyi 0 ile oluşturabilirsiniz:
// diğer diller C gibi. char my_array[20] = {0};
my_array[0]; // => 0
// Diziler değişebilirdir (mutable); O sadece memory! // Dizinin elemanlarını indexlemek diğer diller gibidir, veya
my_array[1] = 2; // diğer diller C gibi.
printf("%d\n", my_array[1]); // => 2 my_array[0]; // => 0
// String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir, // Diziler değişebilirdir (mutable); O sadece memory!
// bu string içerisinde özel bir karakter olan '\0' ile gösterilir. my_array[1] = 2;
// (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek printf("%d\n", my_array[1]); // => 2
// yoktur; derleyici onu bizim için dizinin sonuna ekler.)
char a_string[20] = "This is a string";
printf("%s\n", a_string); // %s bir string formatıdır.
/* // In C99 (and as an optional feature in C11), variable-length arrays (VLAs)
a_string 16 karakter uzunluğundadır. // can be declared as well. The size of such an array need not be a compile
17. karakter NUL karakteridir. // time constant:
18., 19. ve 20. karakterler tanımsızdır.(undefined) printf("Enter the array size: "); // ask the user for an array size
*/ char buf[0x100];
fgets(buf, sizeof buf, stdin);
printf("%d\n", a_string[16]); // => 0 // strtoul parses a string to an unsigned integer
size_t size = strtoul(buf, NULL, 10);
int var_length_array[size]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array);
/////////////////////////////////////// // A possible outcome of this program may be:
// Operatörler // > Enter the array size: 10
/////////////////////////////////////// // > sizeof array = 40
int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol. // String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir,
float f1 = 1.0, f2 = 2.0; // bu string içerisinde özel bir karakter olan '\0' ile gösterilir.
// (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek
// yoktur; derleyici onu bizim için dizinin sonuna ekler.)
char a_string[20] = "This is a string";
printf("%s\n", a_string); // %s bir string formatıdır.
// Aritmatik basittir. /*
i1 + i2; // => 3 a_string 16 karakter uzunluğundadır.
i2 - i1; // => 1 17. karakter NUL karakteridir.
i2 * i1; // => 2 18., 19. ve 20. karakterler tanımsızdır.(undefined)
i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.) */
f1 / f2; // => 0.5, artı veya eksi epsilon printf("%d\n", a_string[16]); // => 0
// i.e., byte #17 is 0 (as are 18, 19, and 20)
// Modüler aritmetikte vardır. // If we have characters between single quotes, that's a character literal.
11 % 3; // => 2 // It's of type `int`, and *not* `char` (for historical reasons).
int cha = 'a'; // fine
char chb = 'a'; // fine too (implicit conversion from int to char)
// Karşılaştırma operatörleri muhtemelen tanıdıktır, ama ///////////////////////////////////////
// C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız. // Operatörler
// 0 false yerine ve diğer herşey true yerine geçmektedir. ///////////////////////////////////////
// (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.)
3 == 2; // => 0 (false)
3 != 2; // => 1 (true)
3 > 2; // => 1
3 < 2; // => 0
2 <= 2; // => 1
2 >= 2; // => 1
// Sayılar üzerinde mantık işlemleri int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol.
!3; // => 0 (Logical not) float f1 = 1.0, f2 = 2.0;
!0; // => 1
1 && 1; // => 1 (Logical and)
0 && 1; // => 0
0 || 1; // => 1 (Logical or)
0 || 0; // => 0
// Bit boyutunda işlem yapmak için operatörler // Aritmatik basittir.
~0x0F; // => 0xF0 (bitwise negation) i1 + i2; // => 3
0x0F & 0xF0; // => 0x00 (bitwise AND) i2 - i1; // => 1
0x0F | 0xF0; // => 0xFF (bitwise OR) i2 * i1; // => 2
0x04 ^ 0x0F; // => 0x0B (bitwise XOR) i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.)
0x01 << 1; // => 0x02 (bitwise left shift (by 1))
0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
/////////////////////////////////////// f1 / f2; // => 0.5, artı veya eksi epsilon
// Kontrol Yapıları
///////////////////////////////////////
if (0) { // Modüler aritmetikte vardır.
printf("I am never run\n"); 11 % 3; // => 2
} else if (0) {
printf("I am also never run\n");
} else {
printf("I print\n");
}
// While Döngüsü // Karşılaştırma operatörleri muhtemelen tanıdıktır, ama
int ii = 0; // C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız.
while (ii < 10) { // 0 false yerine ve diğer herşey true yerine geçmektedir.
printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır. // (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.)
} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " 3 == 2; // => 0 (false)
3 != 2; // => 1 (true)
3 > 2; // => 1
3 < 2; // => 0
2 <= 2; // => 1
2 >= 2; // => 1
printf("\n"); // Sayılar üzerinde mantık işlemleri
!3; // => 0 (Logical not)
!0; // => 1
1 && 1; // => 1 (Logical and)
0 && 1; // => 0
0 || 1; // => 1 (Logical or)
0 || 0; // => 0
int kk = 0; // Bit boyutunda işlem yapmak için operatörler
do { ~0x0F; // => 0xF0 (bitwise negation)
printf("%d, ", kk); 0x0F & 0xF0; // => 0x00 (bitwise AND)
} while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır. 0x0F | 0xF0; // => 0xFF (bitwise OR)
// => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " 0x04 ^ 0x0F; // => 0x0B (bitwise XOR)
0x01 << 1; // => 0x02 (bitwise left shift (by 1))
0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
printf("\n"); // Be careful when shifting signed integers - the following are undefined:
// - shifting into the sign bit of a signed integer (int a = 1 << 32)
// - left-shifting a negative number (int a = -1 << 2)
// - shifting by an offset which is >= the width of the type of the LHS:
// int a = 1 << 32; // UB if int is 32 bits wide
// For Döngüsü ///////////////////////////////////////
int jj; // Kontrol Yapıları
for (jj=0; jj < 10; jj++) { ///////////////////////////////////////
printf("%d, ", jj);
} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
printf("\n"); if (0) {
printf("I am never run\n");
} else if (0) {
printf("I am also never run\n");
} else {
printf("I print\n");
}
/////////////////////////////////////// // While Döngüsü
// Tip Dönüşümleri int ii = 0;
/////////////////////////////////////// while (ii < 10) {
printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır.
} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
// C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe printf("\n");
// dönüştürebilirsiniz.
int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz. int kk = 0;
do {
printf("%d, ", kk);
} while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır.
// => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
// Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır. printf("\n");
printf("%d\n", x_hex); // => Prints 1
printf("%d\n", (short) x_hex); // => Prints 1
printf("%d\n", (char) x_hex); // => Prints 1
// Tip hiçbir hata vermeden taşacaktır(overflow). // For Döngüsü
printf("%d\n", (char) 257); // => 1 (Max char = 255) int jj;
for (jj=0; jj < 10; jj++) {
printf("%d, ", jj);
} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
// Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi. printf("\n");
printf("%f\n", (float)100); // %f formats a float
printf("%lf\n", (double)100); // %lf formats a double
printf("%d\n", (char)100.0);
/////////////////////////////////////// ///////////////////////////////////////
// İşaretçiler (Pointers) // Tip Dönüşümleri
/////////////////////////////////////// ///////////////////////////////////////
// Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret // C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe
// edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini // dönüştürebilirsiniz.
// getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz.
int x = 0; int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz.
printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır.
// (%p işaretçilerin formatıdır) // Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır.
// => Bazı bellek adresleri yazdırılacaktır. printf("%d\n", x_hex); // => Prints 1
printf("%d\n", (short) x_hex); // => Prints 1
printf("%d\n", (char) x_hex); // => Prints 1
// Tip hiçbir hata vermeden taşacaktır(overflow).
printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 eğer karakter 8 bit uzunluğunda ise)
// `char`, `signed char` ve `unsigned char` karakter tiplerinin maksimum uzunluğunu
// belirlemek için <limits.h> kütüphanesindeki CHAR_MAX, SCHAR_MAX ve UCHAR_MAX
// macrolarını kullanınız.
// Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi.
printf("%f\n", (float)100); // %f formats a float
printf("%lf\n", (double)100); // %lf formats a double
printf("%d\n", (char)100.0);
///////////////////////////////////////
// İşaretçiler (Pointers)
///////////////////////////////////////
// Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret
// edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini
// getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz.
int x = 0;
printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır.
// (%p işaretçilerin formatıdır)
// => Bazı bellek adresleri yazdırılacaktır.
// İşaretçiler tanımlanırken * ile başlar // İşaretçiler tanımlanırken * ile başlar
int *px, not_a_pointer; // px sayı tipinde bir işaretçidir. int *px, not_a_pointer; // px sayı tipinde bir işaretçidir.
px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır. px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır.
printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır. printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır.
printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer)); printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer));
// => 64-bit sistemde "8, 4" yazdırılacaktır. // => 64-bit sistemde "8, 4" yazdırılacaktır.
// İşaretçinin adres olarak gösterdiği yerdeki değeri almak için // İşaretçinin adres olarak gösterdiği yerdeki değeri almak için
// değişkenin önüne * işareti ekleyiniz. // değişkenin önüne * işareti ekleyiniz.
printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir, printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir,
// çünkü px değişkeni x in adresini göstermektedir. // çünkü px değişkeni x in adresini göstermektedir.
// Ayrıca siz işaretçinin gösterdiği yerin değerini // Ayrıca siz işaretçinin gösterdiği yerin değerini
// değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz // değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz
// çünkü ++ işleminin önceliği * işleminden yüksektir. // çünkü ++ işleminin önceliği * işleminden yüksektir.
(*px)++; // px'in işaret ettiği değeri 1 artır. (*px)++; // px'in işaret ettiği değeri 1 artır.
printf("%d\n", *px); // => 1 yazdırılır. printf("%d\n", *px); // => 1 yazdırılır.
printf("%d\n", x); // => 1 yazdırılır. printf("%d\n", x); // => 1 yazdırılır.
int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını
// tahsis etmek için iyi bir yöntemdir. // tahsis etmek için iyi bir yöntemdir.
int xx; int xx;
for (xx=0; xx<20; xx++) { for (xx=0; xx<20; xx++) {
x_array[xx] = 20 - xx; x_array[xx] = 20 - xx;
} // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor. } // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor.
// Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor. // Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor.
int* x_ptr = x_array; int* x_ptr = x_array;
// x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20). // x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20).
// Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk // Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk
// elemanlarını gösteren birer işaretçidir. // elemanlarını gösteren birer işaretçidir.
// For example, when an array is passed to a function or is assigned to a pointer,
// it decays into (implicitly converted to) a pointer.
// Exceptions: when the array is the argument of the `&` (address-od) operator:
int arr[10];
int (*ptr_to_arr)[10] = &arr; // &arr is NOT of type `int *`!
// It's of type "pointer to array" (of ten `int`s).
// or when the array is a string literal used for initializing a char array:
char arr[] = "foobarbazquirk";
// or when it's the argument of the `sizeof` or `alignof` operator:
int arr[10];
int *ptr = arr; // equivalent with int *ptr = &arr[0];
printf("%zu %zu\n", sizeof arr, sizeof ptr); // probably prints "40, 4" or "40, 8"
// Diziler ilk elemanlarını gösteren birer işaretçidirler. // Diziler ilk elemanlarını gösteren birer işaretçidirler.
printf("%d\n", *(x_ptr)); // => 20 yazılacaktır. printf("%d\n", *(x_ptr)); // => 20 yazılacaktır.
printf("%d\n", x_array[0]); // => 20 yazılacaktır. printf("%d\n", x_array[0]); // => 20 yazılacaktır.
// İşaretçiler kendi tiplerinde artırılır ve azaltılır. // İşaretçiler kendi tiplerinde artırılır ve azaltılır.
printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır. printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır.
printf("%d\n", x_array[1]); // => 19 yazılacaktır. printf("%d\n", x_array[1]); // => 19 yazılacaktır.
// Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan // Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan
// malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon // malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon
// byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır. // byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır.
int* my_ptr = (int*) malloc(sizeof(int) * 20); int* my_ptr = (int*) malloc(sizeof(int) * 20);
for (xx=0; xx<20; xx++) { for (xx=0; xx<20; xx++) {
*(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir
} // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır. } // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır.
// Eğer ayrımadığınız bir bellek adresini çağırırsanız // Eğer ayrımadığınız bir bellek adresini çağırırsanız
// öngörülmeyen bir değer dönecektir. // öngörülmeyen bir değer dönecektir.
printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak? printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak?
// Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde // Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde
// onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız // onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız
// kapatılana kadar belleğin o kısmını kimse kullanamaz. // kapatılana kadar belleğin o kısmını kimse kullanamaz.
free(my_ptr); free(my_ptr);
// Metin Dizileri(String) birer karakter dizisidir(char array), ama // Metin Dizileri(String) birer karakter dizisidir(char array), ama
// genelde karakter işaretçisi olarak kullanılır. // genelde karakter işaretçisi olarak kullanılır.
char* my_str = "This is my very own string"; char* my_str = "This is my very own string";
printf("%c\n", *my_str); // => 'T' printf("%c\n", *my_str); // => 'T'
function_1(); function_1();
} // main fonksiyon sonu } // main fonksiyon sonu
/////////////////////////////////////// ///////////////////////////////////////
@ -349,6 +406,10 @@ struct rectangle {
int height; int height;
}; };
// It's not generally true that
// sizeof(struct rectangle) == sizeof(int) + sizeof(int)
// due to potential padding between the structure members (this is for alignment
// reasons). [1]
void function_1(){ void function_1(){
@ -414,4 +475,10 @@ typedef void (*my_fnp_type)(char *);
Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/) Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/)
It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the
[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
Diğer taraftan google sizin için bir arkadaş olabilir. Diğer taraftan google sizin için bir arkadaş olabilir.
[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member