Keyword'ler

Keyword'ler konusuna değinilen kısım.

Keyword'ler

Sizeof

sizeof keyword'u, bir değişkenin veya ifadenin bellek kullanımını ölçmek için kullanılır. sizeof, bir değişkenin veya ifadenin boyutunu byte cinsinden döndürür.

Bu keyword genellikle malloc() fonksiyonunda bellekten tahsis edilmek istenen veri türünün bellekte kapladığı yer kadardır. Bunlar işletim sisteminin mimarisi (64 bit, 32 bit) veya programın çalıştığı ortama bağlı olabilir bu yüzden sizeof keyword'u bunun için kullanılabilir.

int* p = (int*)malloc(sizeof(int)*20);

Burada ki ifade de p değişkenine malloc() fonksiyonu aracılığıyla bellekte kapladığı int türü ve çarpı 20 kadarlık bir yer tahsisinde bulunulmuştur.

Goto ve Labels

goto keyword'ü ve labels, bir programın kontrol akışını değiştirerek, programın farklı bölümlerine atlamayı sağlar.

Goto

goto keyword'ü, bir programın kontrol akışını, bir label'e atlamayı sağlar.

Labels

label bir programın herhangi bir yerinde tanımlanabilir. Bu sayede goto keyword'üne o label verilebilir.

int main() 
{
  int a = 10;
  // "start" label'ine atla
  goto start; // goto keyword'u
  printf("Bu kod asla yürütülmeyecek.\n");
start: // "start" label'i
  printf("a değişkeninin değeri: %d\n", a);
  return 0;
}

Break

break ifadesi kullanıldığı yerde bulunan döngüyü veya anahtarlamayı (switch-case) hemen sonlandırır ve programın akışını bir sonraki satırdan veya uygun olan bir yerden devam ettirir.

#include <stdio.h>

int main() 
{
// Döngüler
    int i;
    for (i = 0; i < 5; i++)
    {
        if (i == 3)
            break; // Döngüyü sonlandırır
        printf("%d\n", i);
    }

// Anahtarlamalar (switch-case)
    int choice = 2;
    switch (choice) 
    {
        case 1:
            printf("Birinci durum\n");
            break;
        case 2:
            printf("İkinci durum\n");
            break;
        default:
            printf("Varsayılan durum\n");
            break;
    }
    return 0;
}

İç içe döngülerde break hangi döngü bloğu içinde kullanıldıysa sadece o döngüyü sonlandırır.

#include <stdio.h>

int main() {
    int n1, n2;
    n1 = 10;
    n2 = 5;
    for (int i = 0; i < n1; i++) 
    {
        for (int j = 0; j < num2; j++)
        {
            if (j >= 2)
                break;
            printf("j: %d\n", j);
        }
        printf("i: %d\n", i);    
    }   
    return 0;
}

Burada ki iç içe döngüde break en içte ki döngü bloğunda kullanıldığından sadece o döngüye etki etmiş oldu. Onun üstünde ki döngü şartına bağlı şekilde break'ten etkilenmeden dönmeye devam etti.

Continue

continue genel olarak döngülerde kullanılır. Bu sayede çalıştığı yerde bulunan döngünün mevcut iterasyonunu sonlandırır ve bir sonraki iterasyona geçer. Başka bir deyişle, continue ifadesi, döngü içindeki kodun geri kalanını atlayarak döngüyü devam ettirir.

int main()
{
  for (int i = 0; i < 10; i++)
  {
    if (i % 2 == 0)
      continue;
    printf("i: %d\n", i);
  }
  return 0;
}

Static

static, farklı bağlamlarda farklı anlamlara gelebilen bir anahtar kelimedir. İşte static keyword'ünün farklı kullanım alanları ve anlamları:

Static Değişken

static değişkenler, bir fonksiyon içinde tanımlandıklarında ve static anahtar kelimesi ile işaretlendiklerinde, normal yerel (local) değişkenlerden farklı özelliklere sahip olurlar:

1. Ömür (Lifetime): static değişkenler, programın başlangıcından programın sonuna kadar bellekte kalır. Yani, bir fonksiyon çağrısı sona erdiğinde dahi bellekte saklanmaya devam ederler.

2. Görünürlük (Visibility): static değişkenler, sadece tanımlandıkları fonksiyon içinde görünürlerdir. Başka fonksiyonlardan veya dosyalardan erişilemezler. Bu nedenle, tanımlandıkları fonksiyonun dışında kullanılamazlar.

3. İlk Değer Atama: static değişkenler, program başladığında otomatik olarak sıfırlanır veya başlangıç değeri ile başlatılırlar. Bu, her fonksiyon çağrısında değişkenin ilk değerini yeniden atamanıza gerek olmadığı anlamına gelir.

#include <stdio.h>

void exampleFunction() 
{
    static int count = 0;
    count++;
    printf("Count: %d\n", count);
}

int main() 
{
    exampleFunction(); // Count: 1
    exampleFunction(); // Count: 2
    exampleFunction(); // Count: 3
    return 0;
}

Static Fonksiyon

Bir fonksiyonu static olarak işaretlediğinizde, bu fonksiyonun görünürlüğü sadece aynı kaynak dosyası içinde sınırlı olur. Yani, başka kaynak dosyalarından erişilemez. Bu, fonksiyonun yalnızca tanımlandığı kaynak dosyasında kullanılmasını sağlar ve diğer kaynak dosyalarının kütüphanelerini kirletmeden özel yardımcı işlevler oluşturmanıza olanak tanır.

main.c

#include <stdio.h>

static void localFunction() 
{
    printf("Bu fonksiyon yalnızca main.c içinden erişilebilir.\n");
}

int main() 
{
    localFunction();
    return 0;
}

Void

void, genellikle fonksiyonların dönüş türünü belirtmek için kullanılır:

void helloWorld()
{
    printf("Merhaba, Dünya!\n");
}

Veya return; olarak da bir kullanım olabilir:

void helloWorld()
{
    printf("Merhaba, Dünya!\n");
    return;
}

Genel olarak fonksiyonun ne döndüreceğini ifade etmek için kullanılsa da pointer'lar ile birlikte de kullanılabilir. Kullanımında pointer'ın herhangi bir veri türüne işaret edebileceğini ifade eder. Kısaca "herhangi bir veri türüne işaret edebilen" bir işaretçiyi temsil eder.

int intValue = 42;
float floatValue = 3.14;

void* genericPtr;

genericPtr = &intValue; // int türünden bir işaretçi
printf("int: %d\n", *(int*)genericPtr);

genericPtr = &floatValue; // float türünden bir işaretçi
printf("float: %.2f\n", *(float*)genericPtr);

Bu işaretçiyi kullanırken, işaret ettiği veri türünü bilmeniz ve ona göre bir tip dönüşümü yapmanız gerekebilir.

void* işaretçiler, özellikle fonksiyonlara veri türü bağımsız verileri iletmek veya işlemek için kullanılır. Fonksiyon parametrelerinde void* kullanılarak farklı veri türlerinden veriler işlenebilir.

#include <stdio.h>

void printValue(void* data, char dataType) 
{
    if (dataType == 'i')
        printf("int: %d\n", *(int*)data);
    else if (dataType == 'f')
        printf("float: %.2f\n", *(float*)data);
    else if (dataType == 's')
	    printf("string: %s\n", (char*)data);
    else
        printf("Bilinmeyen veri türü\n");
}

int main() 
{
    int intValue = 42;
    float floatValue = 3.14;
    char stringValue[] = "Hello, World!";

    printValue(&intValue, 'i');
    printValue(&floatValue, 'f');
    printValue(stringValue, 's');

    return 0;
}

Extern

extern, değişkenlerin veya fonksiyonların başka bir kaynak dosyasından erişilebilir olduğunu belirtmek için kullanılır. extern anahtar kelimesi, programın farklı kaynak dosyaları arasında veri ve işlevlerin paylaşılmasını sağlar.

Genel olarak global değişkenler de kullanılır;

main.c

#include <stdio.h>

extern int sharedValue;
int main() 
{
    printf("sharedValue: %d\n", sharedValue);
    return 0;
}

other.c

int sharedValue = 42; // sharedValue değişkeninin tanımı

Ancak fonksiyonlarla da bir kullanım olabilir. Fonksiyonların tanımlarını farklı kaynak dosyalarında gerçekleştirdiğinizde ve bu fonksiyonlara diğer kaynak dosyalarından erişmek istiyorsanız, fonksiyon tanımının başına extern anahtar kelimesini eklemeniz gerekir.

main.c

#include <stdio.h>

extern void sharedFunction(); // sharedFunction fonksiyonu başka bir kaynak dosyada tanımlanmıştır

int main() 
{
    sharedFunction(); // sharedFunction fonksiyonunu çağırır
    return 0;
}

other.c

#include <stdio.h>

void sharedFunction()
{
    printf("Bu fonksiyon başka bir kaynak dosyadan çağrıldı.\n");
}

Typedef

typedef, yeni bir veri türünün (data type) isimlendirilmesini veya özelleştirilmiş bir veri türünün ayarlanmasını sağlar. typedef anahtar kelimesi, kodun daha anlaşılır ve okunabilir olmasına yardımcı olur ve veri türlerini yeniden kullanılabilir kılar.

typedef kelimesinin kullanım prototipi genel olarak şu şekildedir;

typedef eski_veri_turu YeniVeriTuru;

1. Mevcut Veri Tipi Ayarlamaları: typedef ile mevcut bir veri türüne yeni bir isim ayarlanabilir;

typedef int Tamsayi; // int veri türüne "Tamsayi" adını ayarlar

Tamsayi x = 42;

2. Pointer Ayarlamaları: typedef ile işaretçileri tanımlayarak daha okunabilir ve anlaşılır kodlar oluşturabilirsiniz;

typedef int* TamsayiIsaretcisi; // int işaretçisine "TamsayiIsaretcisi" adını ayarlar

int a = 42;
TamsayiIsaretcisi ptr = &a;

3. Struct Ayarlamaları: typedef ile yapılar tanımlanabilir ve bu yapılar daha sonra kullanılmak üzere yeniden adlandırılabilir;

typedef struct 
{
    int x;
    int y;
} Nokta; // Struct'a "Nokta" adını ayarlar

Nokta p1;
p1.x = 3;
p1.y = 5;

typedef struct s_list
{
   void			*content;
   struct s_list	*next;
}  t_list; // Struct'a "t_list" adını ayarlar