C++ Hakkında Bilgiler

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 SINIF YAPISI
İLİŞKİSİ OLMAYAN
FARLILIKLARI VE FAZLALIKLARI

İ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 terel değişklenler 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 <stdio.h>
#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'dür. (NOT: CV++ 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 <stdio.h>

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:

1. Fonksiyon char ya da short parametreyle ç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.
2. 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.
3. Fonksiyon aynı türden const olmayan bir ifadeyle çağırılmışsa ancak
aynı türden const parametreye sahip bir fonksiyon y,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
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
.....
.....
.....
.....
.....
.....
#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, claloc, 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).

Alintidir.