Tabii, hızlıca bir giriş yapalım:
İçindekiler:
C++ ve Java Arasındaki Temel Farklar
Temel C++ Sözdizimi (Syntax) ve Karşılığı Olan Java Kodları
Popüler C++ IDE'leri ve Başlangıç
Basit Bir C++ Programı Yazma, Derleme ve Çalıştırma
1. C++ ve Java Arasındaki Temel Farklar:
Bellek Yönetimi: C++'da bellek yönetimi manueldir (new ve delete kullanılır). Java'da ise Garbage Collector belleği otomatik olarak yönetir.
Platform Bağımsızlık: Java'da yazılan kod JVM üzerinde çalışır, bu sayede platform bağımsızdır. C++ platform bağımlıdır.
Pointers: C++'da pointerlar mevcut, Java'da ise doğrudan pointer kullanımı yok.
2. Temel C++ Sözdizimi ve Karşılığı Olan Java Kodları:
2.1. Ana Fonksiyon (Main Function):
C++
cpp
Copy code
#include <iostream>
using namespace std;
int main() {
cout << "Merhaba, Dünya!" << endl;
return 0;
}
Java
java
Copy code
public class MerhabaDunya {
public static void main(String[] args) {
System.out.println("Merhaba, Dünya!");
}
}
2.2. Değişken Tanımlama:
C++
cpp
Copy code
int sayi = 10;
string metin = "Merhaba";
Java
java
Copy code
int sayi = 10;
String metin = "Merhaba";
2.3. Döngüler:
C++
cpp
Copy code
for(int i = 0; i < 10; i++) {
cout << i << endl;
}
Java
java
Copy code
for(int i = 0; i < 10; i++) {
System.out.println(i);
}
3. Popüler C++ IDE'leri ve Başlangıç:
Visual Studio: Windows için en popüler IDE'lerden biri.
CLion: JetBrains tarafından geliştirilen ve multi-platform bir C++ IDE'si.
Code::Blocks: Hafif ve platformlar arası çalışan başka bir C++ IDE'si.
Başlamak için CLion önerilir. JetBrains aynı zamanda IntelliJ'yi de ürettiği için, arayüzü size tanıdık gelecektir.
4. Basit Bir C++ Programı Yazma, Derleme ve Çalıştırma:
CLion'da:
Yeni bir proje oluşturun.
main.cpp dosyasına yukarıda verilen C++ kodunu ekleyin.
Yeşil oynat (play) düğmesini kullanarak kodu derleyin ve çalıştırın.
Terminal üzerinden (g++ kullanarak):
g++ main.cpp -o cikis
./cikis
Not: Bu, Linux ve MacOS için olan bir derleme işlemidir. Windows'ta farklı komutlar kullanmanız gerekebilir.
Java kodlarıyla karşılaştırarak örnekler ver.
Tabii ki! C++'ın bazı temel özellikleri ve Java'daki karşılıkları ile devam edelim.
5. Koşullu İfadeler:
5.1. if Koşulu:
C++
cpp
Copy code
int sayi = 5;
if (sayi > 3) {
cout << "Sayı 3'ten büyük." << endl;
}
Java
java
Copy code
int sayi = 5;
if (sayi > 3) {
System.out.println("Sayı 3'ten büyük.");
}
5.2. if-else Koşulu:
C++
cpp
Copy code
if (sayi > 3) {
cout << "Sayı 3'ten büyük." << endl;
} else {
cout << "Sayı 3'ten büyük değil." << endl;
}
Java
java
Copy code
if (sayi > 3) {
System.out.println("Sayı 3'ten büyük.");
} else {
System.out.println("Sayı 3'ten büyük değil.");
}
6. Diziler:
6.1. Dizi Tanımlama:
C++
cpp
Copy code
int dizi[5] = {1, 2, 3, 4, 5};
Java
java
Copy code
int[] dizi = {1, 2, 3, 4, 5};
6.2. Diziye Erişim:
C++
cpp
Copy code
cout << dizi[2] << endl; // 3
Java
java
Copy code
System.out.println(dizi[2]); // 3
7. Fonksiyonlar:
7.1. Fonksiyon Tanımlama:
C++
cpp
Copy code
int topla(int a, int b) {
return a + b;
}
Java
java
Copy code
public int topla(int a, int b) {
return a + b;
}
7.2. Fonksiyon Çağırma:
C++
cpp
Copy code
int sonuc = topla(3, 4);
cout << sonuc << endl; // 7
Java
java
Copy code
int sonuc = topla(3, 4);
System.out.println(sonuc); // 7
8. Sınıflar:
8.1. Basit Sınıf Tanımlama:
C++
cpp
Copy code
class Hayvan {
public:
string tur;
void sesCikar() {
cout << "Bir ses" << endl;
}
};
Java
java
Copy code
public class Hayvan {
public String tur;
public void sesCikar() {
System.out.println("Bir ses");
}
}
8.2. Sınıftan Nesne Oluşturma:
C++
cpp
Copy code
Hayvan kedi;
kedi.tur = "Kedi";
kedi.sesCikar();
Java
java
Copy code
Hayvan kedi = new Hayvan();
kedi.tur = "Kedi";
kedi.sesCikar();
9. Pointer'lar ve Referanslar
C++'da bellek adreslerine doğrudan erişim ve manipülasyon yapmamıza olanak tanır. Bu, C++'ı güçlü kılan özelliklerden biridir.
9.1. Pointer Kullanımı:
C++
cpp
Copy code
int sayi = 10;
int* sayiPointeri = &sayi;
cout << *sayiPointeri << endl; // 10
Java'da doğrudan pointer kullanımı yoktur, bu nedenle karşılığı yoktur. Ancak, objeler referansla çalıştırılır.
9.2. Referans Kullanımı:
C++
cpp
Copy code
int x = 10;
int& referans = x;
referans = 20;
cout << x << endl; // 20
Yine, Java'da bu şekilde referans değişkenleri tanımlamamıza izin verilmez.
10. Dinamik Bellek Yönetimi
C++
cpp
Copy code
int* dizi = new int[5]; // 5 elemanlı int dizisi için dinamik olarak bellek ayırır.
delete[] dizi; // Diziyi siler ve belleği geri verir.
Java
Java'da, dinamik bellek yönetimi otomatik olarak yapılır (garbage collector tarafından).
11. Kalıtım (Inheritance)
11.1. Basit Kalıtım:
C++
cpp
Copy code
class Canli {
public:
void nefesAl() {
cout << "Nefes alıyor" << endl;
}
};
class Insan: public Canli {
public:
void konus() {
cout << "Merhaba" << endl;
}
};
Java
java
Copy code
class Canli {
public void nefesAl() {
System.out.println("Nefes alıyor");
}
}
class Insan extends Canli {
public void konus() {
System.out.println("Merhaba");
}
}
12. Polimorfizm
C++
cpp
Copy code
class Sekil {
public:
virtual void ciz() {
cout << "Bir şekil çiziliyor" << endl;
}
};
class Daire: public Sekil {
public:
void ciz() override {
cout << "Bir daire çiziliyor" << endl;
}
};
Java
java
Copy code
class Sekil {
public void ciz() {
System.out.println("Bir şekil çiziliyor");
}
}
class Daire extends Sekil {
@Override
public void ciz() {
System.out.println("Bir daire çiziliyor");
}
}
13. Şablonlar (Templates)
C++'da, şablonlar farklı veri türleri için aynı kodun tekrar kullanılmasını sağlar.
13.1. Fonksiyon Şablonları:
C++
cpp
Copy code
template <typename T>
T maksimum(T a, T b) {
return (a > b) ? a : b;
}
// Kullanımı:
int x = maksimum(3, 5); // 5
double y = maksimum(4.5, 3.2); // 4.5
Java'da generics adında benzer bir yapı vardır:
Java
java
Copy code
public static <T extends Comparable<T>> T maksimum(T a, T b) {
return (a.compareTo(b) > 0) ? a : b;
}
// Kullanımı:
Integer x = maksimum(3, 5); // 5
Double y = maksimum(4.5, 3.2); // 4.5
13.2. Sınıf Şablonları:
C++
cpp
Copy code
template <typename T>
class Kutu {
private:
T icerik;
public:
Kutu(T i) : icerik(i) {}
T getIcerik() { return icerik; }
};
// Kullanımı:
Kutu<int> sayiKutusu(10);
Kutu<string> metinKutusu("Merhaba");
Java
java
Copy code
public class Kutu<T> {
private T icerik;
public Kutu(T icerik) {
this.icerik = icerik;
}
public T getIcerik() {
return icerik;
}
}
// Kullanımı:
Kutu<Integer> sayiKutusu = new Kutu<>(10);
Kutu<String> metinKutusu = new Kutu<>("Merhaba");
14. Çok Biçimlilik (Polymorphism) ve Soyutlama (Abstraction)
C++
cpp
Copy code
class Hayvan {
public:
virtual void sesCikar() = 0; // Saf sanal fonksiyon
};
class Kopek : public Hayvan {
public:
void sesCikar() {
cout << "Hav hav!" << endl;
}
};
Java
java
Copy code
abstract class Hayvan {
public abstract void sesCikar();
}
class Kopek extends Hayvan {
public void sesCikar() {
System.out.println("Hav hav!");
}
}
15. Hata Yakalama (Exception Handling)
C++
cpp
Copy code
try {
// Potansiyel olarak hata verebilecek kod
throw runtime_error("Bir hata oluştu.");
}
catch (runtime_error& e) {
cout << e.what() << endl;
}
Java
java
Copy code
try {
// Potansiyel olarak hata verebilecek kod
throw new Exception("Bir hata oluştu.");
}
catch (Exception e) {
System.out.println(e.getMessage());
}
Bu kısımlar, C++ ve Java'nın ileri seviye özelliklerini kapsar. Her iki dil arasındaki temel benzerlikleri ve farkları anlama konusunda size yardımcı olmuş olmalıyız. Eğer belirli bir konuya daha derinlemesine dalış yapmak veya başka bir konuyu incelemek isterseniz, lütfen belirtin. Devam etmek ister misiniz?
C++'da bir class'dan nasıl bir nesne oluştururum? Kod örnekleri ile anlat.
Elbette! C++'da bir sınıftan nesne oluşturmak oldukça basittir. İlk olarak, bir sınıf tanımlamanız gerekmektedir. Ardından bu sınıfı kullanarak nesneler oluşturabilirsiniz.
Örnek bir Araba sınıfı tanımlayalım:
cpp
Copy code
#include <iostream>
using namespace std;
class Araba {
public:
string marka;
int modelYili;
void bilgileriYaz() {
cout << "Marka: " << marka << ", Model Yılı: " << modelYili << endl;
}
};
Bu sınıf tanımını kullarak Araba sınıfından nesne oluşturmak için şu şekilde kod yazabilirsiniz:
cpp
Copy code
int main() {
Araba benimArabam; // Araba sınıfından bir nesne oluşturduk.
benimArabam.marka = "Toyota";
benimArabam.modelYili = 2022;
benimArabam.bilgileriYaz(); // "Marka: Toyota, Model Yılı: 2022" çıktısını verir.
return 0;
}
Ayrıca, başka bir Araba nesnesi de oluşturabilirsiniz:
cpp
Copy code
Araba digerAraba;
digerAraba.marka = "Ford";
digerAraba.modelYili = 2021;
digerAraba.bilgileriYaz(); // "Marka: Ford, Model Yılı: 2021" çıktısını verir.
Yukarıdaki örneklerde, sınıfın özelliklerine (attributes) doğrudan erişim sağladık ve bu genellikle kötü bir uygulama olarak kabul edilir. Daha iyi bir yaklaşım, private özellikler (attributes) ve public erişim yöntemleri (access methods) kullanmaktır. Ancak buradaki amacımız temel bir sınıf oluşturma ve nesne oluşturma sürecini göstermek olduğu için bu basit yapıyı tercih ettik.
C++'da Java'daki access modifierlar nasıl kullanılır?
C++'da Java'daki erişim belirleyicilere (access modifiers) benzer erişim belirleyicileri bulunmaktadır. İşte temel karşılaştırmaları:
1. private
Java: Bir öğe private olarak işaretlenirse, sadece tanımlandığı sınıf içinden erişilebilir.
C++: Aynı şekildedir. Öğe yalnızca tanımlandığı sınıf içinden erişilebilir.
2. public
Java: Bir öğe public olarak işaretlenirse, herhangi bir sınıf veya fonksiyon tarafından erişilebilir.
C++: Aynı şekildedir. Herhangi bir sınıf veya fonksiyon tarafından erişilebilir.
3. protected
Java: Bir öğe protected olarak işaretlenirse, tanımlandığı sınıf ve bu sınıfı kalıtan alt sınıflar tarafından erişilebilir.
C++: Aynı şekildedir. Ancak, C++'da protected öğelere aynı pakette bulunan diğer sınıflardan erişim izni yoktur (Java'nın bu özelliği vardır).
4. Paket Özel (Java'da varsayılan erişim belirleyici)
Java: Erişim belirleyici belirtilmezse, öğeye sadece aynı paketteki sınıflar tarafından erişilebilir.
C++: C++'da bu tür bir erişim belirleyici bulunmamaktadır.
Kod Örnekleri
Java
java
Copy code
public class Hayvan {
private String isim;
protected int yas;
public String tur;
public Hayvan(String isim) {
this.isim = isim;
}
// isim'e erişim için yöntemler
public String getIsim() {
return isim;
}
public void setIsim(String isim) {
this.isim = isim;
}
}
C++
cpp
Copy code
class Hayvan {
private:
std::string isim;
protected:
int yas;
public:
std::string tur;
Hayvan(std::string ism) : isim(ism) {}
// isim'e erişim için yöntemler
std::string getIsim() {
return isim;
}
void setIsim(std::string ism) {
isim = ism;
}
};
Bu erişim belirleyiciler, sınıfın iç yapısını korumak, kod güvenliğini artırmak ve hataları önlemek için kullanılır. C++ ve Java'da kullanılan bu erişim belirleyiciler, nesne yönelimli programlamadaki soyutlama (abstraction) prensibini destekler.
C++'da public classlar nasıl oluşturulur?
C++'ta "public class" kavramı Java'daki gibi doğrudan mevcut değildir. Java'da, her dosya genellikle yalnızca bir public sınıf içerebilir ve bu sınıfın adı dosyanın adıyla aynı olmalıdır. Ancak C++'ta böyle bir zorunluluk yoktur.
C++'ta, bir sınıfın tüm üyeleri ve yöntemleri başka sınıflar ve fonksiyonlar tarafından erişilebilir olmasını istiyorsanız, bu üyeleri ve yöntemleri public erişim belirleyici altında tanımlamanız gerekir. Ancak sınıfın kendisi "public" ya da "private" olarak işaretlenmez; bu sadece sınıfın içindeki üyelere ve yöntemlere uygulanır.
Örnek:
cpp
Copy code
// Araba.h dosyası
class Araba {
public:
Araba(int y, std::string m); // constructor
void setYil(int y);
int getYil();
void setMarka(std::string m);
std::string getMarka();
private:
int yil;
std::string marka;
};
// Araba.cpp dosyası
#include "Araba.h"
Araba::Araba(int y, std::string m) : yil(y), marka(m) {}
void Araba::setYil(int y) {
yil = y;
}
int Araba::getYil() {
return yil;
}
void Araba::setMarka(std::string m) {
marka = m;
}
std::string Araba::getMarka() {
return marka;
}
Bu örnekte, Araba sınıfı public bir constructor ve public yöntemlere sahipken, sınıfın özellikleri (yil ve marka) private olarak tanımlanmıştır.
Ancak unutulmamalıdır ki, C++'ta birden çok sınıfı aynı dosyada tanımlayabilirsiniz ve bu sınıflardan herhangi biri "public" ya da "private" olarak işaretlenmez. Erişim belirleyiciler yalnızca sınıfın içindeki üyelere ve yöntemlere uygulanır.
Araba.h dosyası ile Araba.cpp dosyası arasındaki fark nedir?
C++'ta kaynak kodu organize etmek için yaygın bir yaklaşım, sınıf tanımlarını (ve bazen ilanları) bir ".h" veya ".hpp" dosyasına (header dosyası) ve sınıfın metodlarının uygulamalarını ise bir ".cpp" dosyasına (kaynak dosyası) yazmaktır. Bu iki dosya türü arasındaki temel farkları aşağıda özetledim:
1. .h (veya .hpp) Dosyası (Header Dosyası)
Genellikle sınıf, fonksiyon ve değişken tanımları ile ilanlarını içerir.
Diğer kaynak dosyaları (.cpp dosyaları) tarafından #include direktifi ile dahil edilir.
Kompilasyon sırasında direkt olarak derlenmez, sadece dahil edildikleri .cpp dosyaları içinde kullanılır.
Aynı başlık dosyasını birden çok .cpp dosyasında dahil edebilirsiniz.
Genellikle karmaşık uygulamaların belirli bir bölümüyle ilgili tüm sınıf ve fonksiyon tanımlarını içerir.
2. .cpp Dosyası (Kaynak Dosyası)
Sınıf ve fonksiyonların uygulamalarını içerir.
Kompilasyon sırasında derlenir ve bağlanır.
.h dosyalarını #include direktifi ile dahil ederek, o dosyada tanımlanan sınıf ve fonksiyon tanımlarını kullanabilir.
Genellikle, uygulamanın gerçek mantığını ve işlevselliğini içeren kodları içerir.
Örnek:
Araba.h
cpp
Copy code
#pragma once // Aynı başlık dosyasının birden fazla kez dahil edilmesini önlemek için kullanılır
#include <string>
class Araba {
public:
Araba(int y, std::string m);
void setYil(int y);
int getYil();
void setMarka(std::string m);
std::string getMarka();
private:
int yil;
std::string marka;
};
Araba.cpp
cpp
Copy code
#include "Araba.h"
Araba::Araba(int y, std::string m) : yil(y), marka(m) {}
void Araba::setYil(int y) {
yil = y;
}
int Araba::getYil() {
return yil;
}
void Araba::setMarka(std::string m) {
marka = m;
}
std::string Araba::getMarka() {
return marka;
}
Bu yapı, büyük projelerde kodun organize ve yönetilebilir olmasını sağlar. Ayrıca, bağımlılıkların ve derleme sürelerinin azaltılmasına da yardımcı olur.
std::string ne anlama gelir?
std::string C++'ın Standart Kütüphanesi'nde tanımlı bir veri tipidir. std::string temel olarak karakter dizilerini (strings) temsil eder ve bu karakter dizileri üzerinde çeşitli işlemleri kolayca gerçekleştirmenizi sağlar.
Bu tanımın içerisindeki std:: bölümü, string sınıfının std (standart) ad alanında (namespace) tanımlandığını belirtir.
C++'ta, birçok standart kütüphane öğesi std ad alanında tanımlıdır. Bu nedenle, bu tür öğeleri kullanırken std:: önekini eklemeniz gerekir. Alternatif olarak, bir dosya içinde using namespace std; ifadesini kullanarak bu öneki eklemekten kaçınabilirsiniz, ancak bu genellikle büyük projelerde ve birden fazla kütüphanenin dahil edildiği durumlarda karışıklığa neden olabileceği için dikkatli kullanılmalıdır.
std::string sınıfı, karakter dizileriyle çalışmayı çok daha kolaylaştıran bir dizi üye fonksiyona sahiptir. Bunlar arasında length(), substr(), append(), find() ve daha birçok fonksiyon bulunmaktadır.
Basit bir std::string kullanımı örneği:
cpp
Copy code
#include <iostream>
#include <string> // std::string için gerekli
int main() {
std::string mesaj = "Merhaba, Dünya!";
std::cout << mesaj << std::endl;
std::cout << "Mesajın uzunluğu: " << mesaj.length() << std::endl;
return 0;
}
Bu örnekte, std::string türünde bir mesaj değişkeni oluşturduk ve bu değişkenin uzunluğunu length() fonksiyonuyla aldık.
C++'da bir nesneyi bellekten nasıl temizlerim?
C++'da nesneleri bellekten temizlemek için new ve delete operatörleri arasında bir ilişki bulunmaktadır. Eğer bir nesneyi dinamik olarak bellekte (heap'te) oluşturduysanız, bu nesneyi kullanımınız bittiğinde delete operatörü ile temizlemelisiniz. Ancak, otomatik ömürlü (yerel değişkenler gibi) veya statik ömürlü nesneler için böyle bir temizleme işlemi yapmanıza gerek yoktur; bu nesneler kendi ömürleri sonunda otomatik olarak temizlenir.
1. Tek Nesne için:
cpp
Copy code
int* ptr = new int; // dinamik olarak bir int oluştur
*ptr = 42;
delete ptr; // bellekten temizle
2. Dizi için:
cpp
Copy code
int* dizi = new int[10]; // dinamik olarak 10 elemanlı bir int dizisi oluştur
delete[] dizi; // dizi olarak ayrılan belleği temizle
Dikkat Edilmesi Gerekenler:
Çift Temizleme (Double Delete): Aynı bellek adresini birden fazla kez delete ile temizlemek tanımsız davranışa neden olur. Bu, genellikle bir programın çökmesine neden olabilir.
Sızıntılar (Memory Leaks): Dinamik olarak ayrılan belleği temizlemeden bırakmak bir bellek sızıntısına neden olabilir. Bu, uzun süre çalışan uygulamalarda ciddi problemlere yol açabilir.
Boş İşaretçiler (Null Pointers): Bir işaretçiyi delete ettikten sonra, bu işaretçiyi nullptr ile başlatmayı düşünebilirsiniz. Bu, yanlışlıkla çift temizleme yapma riskini azaltır.
cpp
Copy code
int* ptr = new int;
delete ptr;
ptr = nullptr; // işaretçiyi nullptr ile başlat
Akıllı İşaretçiler (Smart Pointers): C++11 ve sonrası sürümler, bellek yönetimi için akıllı işaretçileri (std::unique_ptr, std::shared_ptr) sunmaktadır. Akıllı işaretçiler, referans sayımı veya özel bellek yönetimi teknikleri kullanarak belleğin otomatik olarak yönetilmesini sağlar. Bu sayede, manuel olarak new ve delete kullanma zorunluluğunuz azalır. Akıllı işaretçiler, özellikle modern C++ kodunda, bellek sızıntılarından ve diğer bellek yönetimi hatalarından kaçınmanıza yardımcı olabilir.
Bir classtan new anahtar kelimesiyle dinamik olarak oluşturmak ne anlama gelir? Dinamik oluşturmak zorunda mıyım? dinamik oluşturmadığım nesneleri temizlemek zorunda mıyım?
C++'ta bir sınıftan new anahtar kelimesiyle bir nesne oluşturmak, nesnenin heap (veya serbest depo) üzerinde dinamik olarak tahsis edilmesi anlamına gelir.
new ile Dinamik Oluşturma:
cpp
Copy code
class Araba {
// sınıf içeriği...
};
Araba* arabaPtr = new Araba();
Bu kod parçasında, Araba tipinde bir nesne dinamik olarak oluşturulmuş ve bu nesnenin bellekteki adresi arabaPtr işaretçisine atanmıştır.
Dinamik Oluşturmanın Avantaj ve Dezavantajları:
Avantajları:
Ömür Kontrolü: Dinamik olarak ayrılan nesnelerin ömrü, onları delete anahtar kelimesiyle temizleyene kadar devam eder. Bu, nesnenin ne zaman oluşturulacağını ve ne zaman temizleneceğini kontrol etmek istediğinizde yararlıdır.
Bellek Esnekliği: Büyük veri yapılarını veya dizi benzeri yapıları dinamik olarak tahsis etmek, belleği daha esnek bir şekilde kullanmanıza olanak tanır.
Dezavantajları:
Bellek Yönetimi Yükü: Dinamik olarak tahsis edilen belleği manuel olarak temizlemek zorundasınızdır. Bu, bellek sızıntılarına veya diğer bellek ile ilgili hatalara yol açabilir.
Performans Maliyeti: Dinamik bellek tahsisi, otomatik bellek tahsisinden (yığın üzerinde) genellikle daha yavaştır.
Dinamik Olarak Oluşturulmayan Nesneler:
Dinamik oluşturulmayan nesneler, genellikle fonksiyonların yerel değişkenleri olarak tanımlanırlar ve bu nesneler yığın (stack) üzerinde oluşturulur.
cpp
Copy code
void fonksiyon() {
Araba araba; // Yığın üzerinde bir Araba nesnesi oluştur
}
Bu tür nesneleri manuel olarak temizlemenize gerek yoktur. Nesnenin kapsamı (örneğin, fonksiyon) sona erdiğinde otomatik olarak bellekten temizlenir.
Sonuç:
Dinamik olarak oluşturulan nesneler (new ile) manuel olarak temizlenmelidir (delete ile).
Yığın üzerinde otomatik olarak oluşturulan nesneleri manuel olarak temizlemenize gerek yoktur; kapsamları sona erdiğinde otomatik olarak temizlenirler.
Her zaman dinamik olarak nesne oluşturmanız gerekmez. Ancak, nesnenin yaşam süresini veya bellek boyutunu dinamik olarak kontrol etmeniz gerekiyorsa bu yöntemi kullanmanız gerekir. Modern C++'da, dinamik bellek yönetimini kolaylaştırmak için akıllı işaretçiler (örneğin, std::unique_ptr ve std::shared_ptr) gibi araçlar bulunmaktadır.
Javadaki collectionların C++'daki karşılığı nedir?
Java'da, koleksiyonlar (collections) Java Collections Framework (JCF) içerisinde tanımlıdır ve çok sayıda veri yapısı ve algoritma sunar. C++'da, bu yapıların birçoğuna karşılık gelen yapılar C++ Standart Kütüphanesi (STL - Standard Template Library) içinde bulunabilir. İşte bazı Java koleksiyonları ve onların C++'daki karşılıkları:
List (Java) -> vector (C++)
Sıralı elemanlara sahip dinamik dizi.
Hem Java'daki ArrayList hem de C++'daki std::vector rastgele erişim sağlar.
LinkedList (Java) -> list (C++)
Çift yönlü bağlantılı liste.
Hem Java'daki LinkedList hem de C++'daki std::list elemanların dinamik olarak eklenip çıkarılmasını destekler.
Set (Java) -> set (C++)
Elemanların benzersiz olduğu bir koleksiyon.
C++'daki std::set, elemanları otomatik olarak sıralar.
HashSet (Java) -> unordered_set (C++)
Elemanların benzersiz olduğu bir koleksiyon.
Hem HashSet hem de std::unordered_set karma tabanlıdır ve elemanları sıralamaz.
Map (Java) -> map (C++)
Anahtar-değer çiftlerini saklar.
C++'daki std::map, anahtarları otomatik olarak sıralar.
HashMap (Java) -> unordered_map (C++)
Anahtar-değer çiftlerini saklar.
Hem HashMap hem de std::unordered_map karma tabanlıdır ve anahtarları sıralamaz.
Stack (Java) -> stack (C++)
LIFO (Last In, First Out) prensibine göre çalışan bir veri yapısı.
Queue (Java) -> queue (C++)
FIFO (First In, First Out) prensibine göre çalışan bir veri yapısı.
Deque (Java) -> deque (C++)
Hem baştan hem de sondan eleman eklemeye ve çıkarmaya izin veren bir çift yönlü kuyruk.
PriorityQueue (Java) -> priority_queue (C++)
Öncelikli kuyruk yapısı. Elemanlar öncelik sırasına göre saklanır.
Java'daki koleksiyonlar ve C++'daki STL veri yapıları arasında kullanım ve uygulama açısından bazı farklılıklar bulunmaktadır, ancak temel prensipleri benzerdir. C++'da bu veri yapılarını kullanabilmek için uygun başlık dosyalarını (#include direktifleriyle) dahil etmeniz gerekir. Örneğin, std::vector için #include <vector> direktifini eklemelisiniz.
Java bilen ve C++ öğrenmeye çalışan bir developer için SSS ve Cevapları
Java'dan C++'a geçiş yapan bir geliştirici için Sıkça Sorulan Sorular (SSS) ve Cevapları şu şekildedir:
1. Java'da her şey bir sınıf içinde mi? C++'ta durum nedir?
Cevap: Java'da tüm fonksiyonlar ve değişkenler bir sınıf içinde tanımlanır. Ancak C++'ta, fonksiyonlar ve değişkenler sınıf dışında da tanımlanabilir.
2. Java'da garbage collector var. C++'ta durum nedir?
Cevap: C++'da otomatik bir garbage collector yoktur. Dinamik olarak ayrılan belleği new ile tahsis edip delete ile manuel olarak serbest bırakmalısınız. Ancak, modern C++'da akıllı işaretçiler (smart pointers) gibi araçlarla bellek yönetimi daha kolaylaştırılmıştır.
3. Java'da array'lerin boyutu nasıl alınır? C++'ta ne yapmalıyım?
Cevap: Java'da, array'in boyutunu length özelliği ile alabilirsiniz. C++'ta std::array veya std::vector kullanıyorsanız, size() fonksiyonunu kullanmalısınız.
4. Java'da String nedir? C++'ta neye karşılık gelir?
Cevap: Java'da, String özel bir sınıftır ve metin işleme için birçok yöntem sağlar. C++'da, std::string bu role sahiptir ve #include <string> ile dahil edilir.
5. Java'da paketler nasıl kullanılır? C++'ta benzeri nedir?
Cevap: Java'da, kodu organize etmek için paketler kullanılır. C++'da, başlık dosyaları (header files) ve kaynak dosyaları (source files) ile kod organize edilir ve namespace kullanılarak kod gruplandırılır.
6. Java'da çoklu kalıtım destekleniyor mu? C++'ta durum nedir?
Cevap: Java'da sınıflar arasında çoklu kalıtım desteklenmez; ancak, bir sınıf birden fazla arayüzü (interface) uygulayabilir. C++'da, bir sınıf birden fazla sınıftan türetilebilir, bu nedenle çoklu kalıtım desteklenir.
7. Java'da otomatik tür dönüşümü nasıl çalışır? C++'ta bu nasıl ele alınır?
Cevap: Hem Java'da hem de C++'ta otomatik tür dönüşümü (implicit type conversion) vardır. Ancak, C++'ta tür dönüşümü daha karmaşık olabilir ve aynı zamanda kullanıcı tanımlı tür dönüşümü de desteklenir.
8. Java'da final ne anlama gelir? C++'ta eşdeğeri nedir?
Cevap: Java'da final, bir değişkenin değerinin değiştirilemeyeceğini (sabit olduğunu) belirtirken, bir sınıfın türetilemeyeceğini veya bir yöntemin (method) üzerine yazılamayacağını belirtir. C++'ta const anahtar kelimesi, bir değişkenin sabit olduğunu belirtir. Bir sınıfın türetilemeyeceğini belirtmek için özel teknikler kullanılır, ve bir fonksiyonun üzerine yazılmaması için virtual ve override anahtar kelimeleri kullanılır.
Bu SSS listesi, Java'dan C++'a geçen bir geliştiricinin karşılaşabileceği bazı temel sorunları ele alır. Ancak, C++'ın karmaşıklığı ve zenginliği göz önüne alındığında, bu konu hakkında daha çok soru olabilir.
9. Java'da dizi sınırları kontrol edilirken, C++'ta durum nedir?
Cevap: Java'da bir diziye erişirken sınırların dışına çıkmak isterseniz, ArrayIndexOutOfBoundsException hatası alırsınız. C++'da, std::vector gibi konteynerlerde at() fonksiyonu kullanılarak güvenli bir şekilde erişim sağlanabilir; aksi halde sınırların dışına çıkan bir erişim tanımsız davranışa (undefined behavior) yol açar ve bu genellikle programın çökmesine neden olur.
10. Java'da "exception" nasıl işlenir? C++'ta bu konsept nasıl ele alınır?
Cevap: Java'da, try, catch ve finally blokları kullanılarak istisnalar (exceptions) ele alınır. C++'ta da try ve catch kullanılır, ancak finally bloğu yoktur. Bunun yerine, C++'ta kaynakların otomatik olarak temizlenmesi için RAII (Resource Acquisition Is Initialization) prensibi kullanılır.
11. Java'da soyut sınıflar ve arayüzler (interfaces) var. C++'ta benzer yapılar nasıl tanımlanır?
Cevap: C++'da da soyut sınıflar (abstract classes) bulunmaktadır. Bir sınıfın soyut olabilmesi için en az bir soyut (yani gövdesi olmayan) fonksiyona sahip olması gerekir. C++'da arayüz kavramı doğrudan bulunmasa da, sadece sanal fonksiyonlardan oluşan soyut sınıflar, Java'daki arayüzlerle benzer bir amaca hizmet eder.
12. C++'da "pointer" nedir ve Java'da karşılığı var mıdır?
Cevap: C++'da, bir pointer bir bellek adresini gösteren bir değişken türüdür. Java'da doğrudan pointer kavramı yoktur; bunun yerine, tüm nesne değişkenleri aslında nesnenin bellek adresine bir işaretçi olarak çalışır, ancak bu işaretçilere doğrudan erişim izni verilmez.
13. Java'da paket yöneticisi olarak Maven veya Gradle gibi araçlar var. C++ için benzeri nedir?
Cevap: C++ için paket yönetimi genellikle platforma ve kullanılan araçlara bağlıdır. Ancak, son yıllarda C++ projeleri için Conan ve vcpkg gibi popüler paket yöneticileri ortaya çıkmıştır.
14. Java'da çok iş parçacıklı (multi-threading) programlama nasıl yapılır ve C++'da bu konsept nasıl ele alınır?
Cevap: Java'da Thread sınıfı veya Runnable arayüzü kullanılarak çok iş parçacıklı programlama yapılır. C++11 ile birlikte, C++'da std::thread sınıfı sunulmuş ve bu sınıf, çok iş parçacıklı programlamayı kolaylaştırmıştır.
Bu eklemelerle, Java'dan C++'a geçmeye çalışan bir geliştirici için önemli konuların birçoğuna değinilmiş olmalıdır. Ancak, her iki dil de çok geniş olduğundan, belirli bir konuda daha fazla bilgi gerektiğinde ilgili dökümantasyona başvurmak her zaman en iyisidir.