C++ programlama dilinde operatör aşırı yüklemesi, sınıfların işlevselliğini arttırarak var olan bir operatörün farklı veri türleri üzerinde farklı işlemler yapmasına olanak sağlar Karşılaştırma, atama, aritmetik, ve akım operatörleri en yaygın aşırı yüklenen operatörlerdir Örneğin, öğrenci nesneleri arasında notlarına göre karşılaştırma yapmak için '>' operatörü aşırı yüklenebilir Operatör aşırı yüklemesi, C++ programcılarına daha fazla esneklik ve daha az kod yazma imkanı sunar
C++ programlama dili, operatör aşırı yüklemeye izin vererek sınıfların işlevselliğini arttırmaktadır. Bu özellik, var olan bir operatörün farklı veri türleri üzerinde farklı işlemler gerçekleştirmesine olanak tanımaktadır.
Örneğin, karşılaştırma, atama, aritmetik ve akım operatörleri C++ dilinde en yaygın aşırı yüklenen operatörler arasında yer almaktadır. Karşılaştırma operatörleri, özel bir sınıf için aşırı yüklenebilir ve sınıf nesneleri arasında karşılaştırma yapmak için kullanılır. Atama operatörü, nesne başka bir nesneye atanırken kullanılmaktadır ve nesneler arasında farklı türlerdeki verileri atamak için kullanılabilir. Aritmetik operatörler, sınıf için aşırı yüklenebilir ve farklı sınıf nesneleri arasındaki matematiksel işlemler gerçekleştirilebilir. Son olarak, akım operatörleri sınıfın nesnesi için aşırı yüklenebilir ve nesnelerin değerlerinin bir dosyaya veya ekrana yazılmasını sağlar.
Aşırı Yükleme Nedir?
Aşırı yükleme, C++ dilindeki bir özelliktir. Bu özellik sayesinde, var olan bir operatör farklı veri türlerindeki veriler üzerinde farklı işlemler gerçekleştirebilir. Yani, bir operatörün görevi normal durumlarda sınırlandığı işlemler dışında daha başka işlevleri de yerine getirebilir. Aşırı yükleme, C++ programcılarının kodlarını daha esnek ve pratik bir şekilde yazmasını sağlar.
Örneğin, artık bir dizi sınıf veya veri yolu oluşturup, aynı operatörü her defasında farklı tiplerdeki veriler için yeniden yazmak zorunda kalmazsınız. Ayrıca, operatör aşırı yüklemesi kullanılarak, sınıflar arasındaki karmaşık işlemler daha kolay bir şekilde gerçekleştirilir.
Hangi Operatörler Aşırı Yüklenebilir?
C++ programlama dilinde, sınıfların ve nesnelerin daha kolay kullanılması ve programlama sürecinin daha verimli hale getirilmesi için operatör aşırı yükleme kullanılır. Aşırı yükleme, aynı operatörlerin farklı tiplerdeki nesneler üzerinde farklı işlemler yapabilmesi anlamına gelir.
Hangi operatörlerin aşırı yüklenebileceği, programcıların ihtiyacına bağlıdır. C++ dilinde en yaygın aşırı yüklenen operatörler arasında atama, karşılaştırma, aritmetik ve akım operatörleri bulunur.
Atama operatörü (=), nesneler arasında farklı türlerdeki verileri atamak için kullanılır. Karşılaştırma operatörleri (==, !=, <, >, <=, >=), sınıf nesneleri arasında karşılaştırma yapmak için kullanılır. Aritmetik operatörler (+, -, *, /), matematiksel işlemler için kullanılırken, akım operatörleri (<<, >>), sınıf nesnesinin değerlerini bir dosyaya veya ekrana yazmak için kullanılır.
Bu operatörlerin aşırı yüklenmesi, programcılara daha fazla esneklik ve daha az kod yazma imkanı sağlar. Örneğin, bir Öğrenci sınıfının iki örneği, öğrencilerin notlarına göre kolayca karşılaştırılabilir.
Karşılaştırma Operatörleri
C++ sınıflarında operatör aşırı yükleme konusu oldukça geniş bir konudur. Karşılaştırma operatörleri (==, !=, <, >, <=, >=), özel bir sınıf için aşırı yüklenebilir. Bu operatörler, sınıf nesneleri arasında karşılaştırma yapmak için kullanılır.
Örneğin, bir öğrenci sınıfının iki örneği, öğrencilerin notlarına göre karşılaştırılabilir. Aşağıdaki örnekte, '>' operatörü aşırı yüklenebilir:
| Operator | Description |
|---|---|
| > | Greater than |
| < | Less than |
| >= | Greater than or equal to |
| <= | Less than or equal to |
| == | Equal to |
| != | Not equal to |
Yukarıdaki tabloya göre, '>' operatörü 'Greater than' yani büyüktür işlemini gerçekleştirir. Aşağıdaki örnek kodda, iki öğrenci nesnesi karşılaştırılmaktadır.
bool operator>(Student s1, Student s2){ return (s1.grade > s2.grade);}Yukarıdaki kodda, '>' operatörü iki öğrenci nesnesi arasında, öğrencilerin notlarına göre karşılaştırma yapmaktadır. Aşağıdaki örnek nesnelerin karşılaştırılması örneğinde, ikinci öğrenci nesnesi, birinci öğrenci nesnesine göre daha yüksek bir not alır:
Student s1("Ali", 85);Student s2("Ayşe", 92);if (s1 > s2) { cout << "Ali daha düşük bir not aldı";} else { cout << "Ayşe daha yüksek bir not aldı";}Bu kod çalıştırıldığında, "Ayşe daha yüksek bir not aldı" çıktısı alınır. Gördüğünüz gibi, operatör aşırı yüklemesi sayesinde öğrenci nesneleri arasında karşılaştırma işlemi yapılmıştır.
Örnek:
Aşağıdaki örnekte, bir Öğrenci sınıfının iki örneği, öğrencilerin notlarına göre karşılaştırılmaktadır:
| Öğrenci Adı | Notu |
|---|---|
| Ali | 85 |
| Ahmet | 92 |
Yukarıdaki tabloda, Ali'nin notu 85, Ahmet'in notu ise 92'dir. Bu öğrencilerin notlarının karşılaştırılması için > (büyüktür) operatörü aşırı yüklenir:
bool operator>(Student s1, Student s2){ return (s1.grade > s2.grade);}Yukarıdaki kod, iki öğrenci sınıf nesnesini alır ve bunların notlarını karşılaştırır. Daha sonra, büyük olan öğrencinin adı ekrana yazdırılır.
Bu örnekte, > (büyüktür) operatörü Öğrenci sınıfı için aşırı yüklenmiştir, ancak diğer karşılaştırma operatörleri (==, !=, <, <=, >=) aynı şekilde aşırı yüklenebilir.
Örnek Kod:
Bu örnek kod, bir öğrenci sınıfının iki nesnesi arasında öğrencilerin notlarına göre karşılaştırma yapmak için aşırı yükleme kullanır.
Operatör aşırı yüklemesi şöyle çalışır: İki öğrenci nesnesi alınacak ve bir bool değeri döndüren operatör aşırı yükleme işlevi oluşturulacaktır. En yüksek notu alan öğrenci daha büyük kabul edilir ve karşılaştırmanın sonucu True olarak döndürülür. Eğer notlar eşitse, karşılaştırmanın sonucu False olarak döndürülür.
| Kod Açıklaması | Aksiyon |
|---|---|
| bool operator>(Student s1, Student s2) | Operatör aşırı yükleme işlevi tanımlar. |
| return (s1.grade > s2.grade); | İki öğrenci nesnesi arasında karşılaştırma yapar. En yüksek notu alan öğrenci daha büyük kabul edilir. |
Bu örnek kod, öğrenci nesneleri arasında öğrencilerin notlarına göre bir sıralama işlemi yapmayı mümkün kılar. Yazılım geliştiriciler, bu örnekte olduğu gibi, aşırı yüklenmiş operatörleri kullanarak özel işlevler oluşturabilirler. Bu özellik, C++ programlama dili ile birlikte sunulan büyük bir avantajdır ve programlama işlemlerinin çok daha kolay ve hızlı bir şekilde gerçekleştirilmesine olanak tanır.
return (s1.grade > s2.grade);Sınıflarda operatör aşırı yükleme konusunda karşılaştırma operatörleri (==, !=, <, >, <=, >=) oldukça sık kullanılır. Özellikle, aynı sınıfa ait nesneler arasında karşılaştırma yapmak gerektiğinde bu operatörlerin aşırı yüklenmesi işlemi devreye girer. Örneğin, bir Öğrenci sınıfında öğrencilerin notlarına göre sıralama yapabilmek için karşılaştırma operatörlerinden > işareti aşırı yüklenerek s1.grade > s2.grade şartı kontrol edilir ve sonuç olarak true veya false döndürülür.
}C++ sınıfları, programlamada oldukça yaygın olarak kullanılır. Sınıfların kullanımı, verilerin güvenliğini sağlarken, aynı zamanda verilerin işlenmesinde kullanılan işlemleri de hızlandırır. Ancak, bazı durumlarda C++'da mevcut olan operatörlerin sınıf nesneleri için yeterli olmadığı durumlar ortaya çıkabilir. İşte tam da bu noktada operatör aşırı yükleme devreye girer.
Operatör aşırı yükleme, aynı operatörün farklı türlerdeki veriler için farklı işlemler gerçekleştirmesine izin verir. C++ dilinde atama, karşılaştırma, aritmetik ve akım gibi birçok operatör aşırı yüklenebilir. Operatör aşırı yükleme, sınıf nesneleri arasında matematiksel işlemler veya karşılaştırmalar yapmak gibi farklı işlemler gerçekleştirmeye olanak sağlar.
Atama Operatörleri
C++ sınıflarında atama operatörü (=), bir sınıf nesnesi, başka bir sınıf nesnesine atandığında kullanılır. Aşırı yükleme, nesneler arasında farklı veri tipleri olduğunda atama işlemi için kullanılabilir.
Örneğin, bir Dikdörtgen sınıfı örneği oluşturulabilir. Bu sınıfın uzunluk ve genişlik özellikleri olsun. Aşırı yükleme, farklı veri tiplerini atama işleminde kullanabilir.
| Operator | Function |
|---|---|
| =(assignment operator) | Assigns values from one object to another |
Aşağıdaki örnek kod, Dikdörtgen sınıfının atama operatörünün aşırı yüklenmesini gösterir:
Rectangle operator=(const Rectangle& r) { length = r.length; width = r.width; return *this;}Yukarıdaki kod, bir dikdörtgen nesnesinin bir başka dikdörtgen nesnesine atanmasını sağlar. Aşırı yüklenmiş böyle bir atama operatörü, farklı veri türleri arasında da kullanılabilir. Örneğin, bir Dikdörtgen sınıfının bir kareye atanması sağlanabilir.
Bir sınıfın atama operatörünün aşırı yüklenmesi, programcılara daha fazla esneklik sağlar ve kodun daha anlaşılır olmasını sağlar.
Örnek:
Aşırı yüklemelerin kullanımını açıklamak için bir örnek verelim: Öğrenci sınıfında, bir dizi oluşturuldu ve içinde öğrencilerin adları ve notları var. Bu diziyi başka bir diziye kopyalamak, öğrencilerin listesinde bir değişiklik yapmadan dışarıdan ulaşılabilir bir yedek oluşturmak için gereklidir.
Bunun için, atama operatörü aşırı yüklenerek öğrenci sınıfı objeleri kolayca kopyalanabilir. Aşağıdaki örnekte, 'dizi1' adlı bir Öğrenci sınıfı örneği oluşturuldu ve 2 öğrenci nesnesini içeriyor. 'Dizi2' adlı başka bir öğrenci sınıfı örneği oluşturulacaktır. Dizi1'deki öğrenciler, atama operatörü aşırı yüklemesi kullanılarak, sonradan dizi 2'ye kopyalanacaktır.
| dizi1 | dizi2 |
|---|---|
| Öğrenci 1: Ali | |
| Notu: 85 | |
| Öğrenci 2: Veli | |
| Notu: 92 |
Aşağıdaki örnekte atama operatörü aşırı yüklemesi kullanılarak, 'dizi1' öğrenci sınıfı örneği 'dizi2' sınıfına kopyalanıyor:
Öğrenci dizi1[2] = { Öğrenci ("Ali", 85), Öğrenci ("Veli", 92),}; Öğrenci dizi2[2]; // Atama operatörü aşırı yüklemedizi2[0] = dizi1[0];dizi2[1] = dizi1[1];Aşırı yükleme, belirli operatörlerin kullanımını daha doğal hale getirir. Ayrıca C++ dilindeki özel operatörlerin kullanımında daha fazla esneklik sağlar.
Örnek Kod:
Student operator=(Student &s) { name = s.name; grade = s.grade; return *this;}
Bu örnek kod, atama operatörünün sınıf içinde nasıl aşırı yükleneceğini gösterir. Sınıf içindeki bir atama operatörü, bir nesneyi başka bir nesneye aktarırken kullanılır. Atama işlemi yapılırken nesneler arasında veri tipi uyumuna dikkat etmek gereklidir. Bu örnek kodda yer alan sınıf, öğrencinin adı ve notu bilgilerini içerir.
Aşırı yükleme, atama operatörü için iki özel parametre alır: "=" operatörü ve const Student &s parametresi. "=" operatörü, atama operatörü için gerekli belirleyici işarettir. Const Student &s parametresi, öğrenci sınıfında tanımlanmış bir const referanstır. Bu parametre, bir öğrenci nesnesini aktarmak için kullanılır ve referans olarak alınması, RAM bütçesine olumlu yansımalar sağlar.
Örnekte, const öğrenci referansının alanları, öğrenci nesnesinin ilgili alanlarına eşlenebildiği için, doğrudan öğrenci adı ve notu alanlarına atanabilirler. Sınıfın kendisi de nesne olarak döndürülebilir, bu da yinelenen kod miktarını azaltır.
name'name = s.name;' atama operatörünün aşırı yüklenmesi, bir sınıf nesnesinin başka bir sınıf nesnesine atanması durumunda kullanılır. Bu işlem, sınıfın sahip olduğu herhangi bir veri elemanının diğer bir sınıfın aynı veri elemanına atanmasında kullanılabilir.
Örneğin, bir Öğrenci sınıfı örneğindeki öğrenci adları, başka bir öğrenci sınıfına atanabilir. Bu durumda, aşırı yükleme kullanılarak 'name = s.name;' atama operatörü tanımlanabilir. Bu operatörle, mevcut sınıf nesnesindeki ad, diğer sınıfın nesnesindeki ad ile değiştirilebilir.
Aşağıdaki örnek kod, 'name = s.name;' atama operatörünün tanımını göstermektedir:
Student operator=(Student &s) { name = s.name; grade = s.grade; return *this;}Bu kod, mevcut öğrenci sınıf nesnesinin adını, başka bir öğrenci sınıf nesnesindeki ad ile değiştirir. Ayrıca, sınıfın diğer veri elemanları da, atama operatörü aracılığıyla diğer öğrenci sınıf nesnesindeki veri elemanlarına atanabilir.
Atama operatörü, sınıf nesneleri arasında veri kopyalama işlemlerinde sıkça kullanılan bir operatördür. C++ dilinde aşırı yüklenen atama operatörü, sınıf nesneleri arasındaki veri kopyalama işlemlerinde büyük bir kolaylık sağlamaktadır.
Bir sınıf nesnesinde bulunan grade değişkeni, bir başka sınıf nesnesindeki grade değişkenine atanırken, atama operatörü (=) aşırı yüklemesi kullanılabilir. Bu işlem sırasında, nesneler arasında farklı türdeki verileri atamak mümkündür.
Örneğin, bir Öğrenci sınıfına ait iki nesne oluşturulduğunu ve bunların notlarına göre karşılaştırılacağını düşünelim. Atama operatörü, notu daha yüksek olan öğrencinin nesnesinin notunu, notu daha düşük olan öğrencinin nesnesine atayabilir.
| Öğrenci 1 | Öğrenci Adı: Ali | Notu: 90 |
|---|---|---|
| Öğrenci 2 | Öğrenci Adı: Ayşe | Notu: 80 |
Yukarıdaki örnekte, atama operatörü kullanılarak, Ali'nin notu Ayşe'nin notuna atanabilir:
Ali = Ayşe;
Sonuç olarak, Ali'nin notu 80 olacaktır.
return *this;return *this;
Atama operatörü aşırı yüklemesi, bir sınıf nesnesinin kendisini döndürür. Bu işlem, bir nesneyi başka bir nesneye atarken kullanılır. Atama operatörü, sınıf öğelerinin birbirine atanması işlemini gerçekleştirir.
Bir nesne kopyalandığında, özdeş bir çiftin yaratılması mümkündür. Bu da bellek kullanımının artmasına neden olur. Atama operatörü, bu durumda kullanılabilir ve bellek kullanımını azaltabilir.
Atama operatörü aşırı yüklemesi, bir sınıf nesnesinin kendisini döndürmesi gerektiği için, bir işlem gerçekleştirildiğinde, özünü koruyacak şekilde geri dönmemesi durumunda hata verebilir. Bu nedenle, bir işlem gerçekleştirildikten sonra nesne kendisine dönülecek şekilde ayarlanmalıdır.
Aşağıda bir örnek verilmiştir:
| Student s1("John", 90); | ||
|---|---|---|
| Name: | John | |
| Grade: | 90 | |
| Student s2("Jane", 85); | ||
| Name: | Jane | |
| Grade: | 85 | |
| s2 = s1; | ||
| Name: | John | |
| Grade: | 90 | |
Yukarıdaki örnekte, "s1" öğrenci nesnesinin özellikleri, "s2" öğrenci nesnesine atanmıştır. "s2=s1" ifadesi, "s1" için ayrılan bellek alanındaki bilgilerin "s2" için ayrılmış bellek alanına kopyalanmasını sağlar. Bu işlem sonucunda, "s2" hocanın adı "John" ve derecesi "90" olarak ayarlanmıştır.
}C++ dilinde, sınıflar için operatör aşırı yükleme oldukça önemlidir. Bu işlem, farklı türlerdeki veriler üzerinde farklı işlemler gerçekleştirme imkanı sağlar. Aşırı yükleme sayesinde, nesneler arasındaki karşılaştırmalar, atamalar, aritmetik işlemler ve akım işlemler kolayca gerçekleştirilebilir. Operatör aşırı yükleme, kod okunurluğunu ve yeniden kullanılabilirliği arttırır.
Aritmetik Operatörler
C++ programlama dilinde bulunan aritmetik operatörler, sınıflar için aşırı yüklenebilir. Bu operatörlerle, farklı sınıf nesneleri arasında matematiksel işlemler yapılabilir. Yüklenen aritmetik operatörler şunlardır:
- +
- -
- *
- /
Bir sınıf nesnesinin bu operatörlere sahip olması, sınıfın matematiksel işlemleri yapabilir hale gelmesini sağlar. Örneğin, bir dikdörtgen sınıfı örneği oluşturup, bunları birleştiren bir işlem yapabiliriz:
Öncelikle, Rectangle sınıfını oluşturalım ve bu sınıftan iki örneğimiz olsun:
| Dikdörtgen 1 | Dikdörtgen 2 |
|---|---|
| Uzunluk: 10 | Uzunluk: 5 |
| Genişlik: 5 | Genişlik: 10 |
Şimdi, bu iki dikdörtgeni birleştirerek yeni bir dikdörtgen oluşturalım:
Rectangle operator+(const Rectangle& r) { Rectangle result; result.setLength(length + r.length); result.setWidth(width + r.width); return result; }Bu kodda, + operatörü, iki Rectangle nesnesinin uzunluğunu ve genişliğini toplar ve yeni bir Rectangle nesnesi döndürür. Bu şekilde, farklı sınıf nesneleri arasında matematiksel işlemler yapılabiliyor.
Örnek:
Bu örnekte, C++ sınıflarında aşırı yükleme kullanarak bir dikdörtgen sınıfı örneği oluşturup, birleşik bir dikdörtgen hesaplaması yapabiliriz. İlk olarak, Dikdörtgen sınıfı için gerekli değişkenleri tanımlamalıyız. Bunlar, uzunluk ve genişlik değerleridir. Sonrasında, dikdörtgenin alanını hesaplayarak, birleşik bir dikdörtgen sınıfından elde edebiliriz.
| Değişken | Tipi | Açıklama |
|---|---|---|
| length | double | Dikdörtgenin uzunluğunu tutar |
| width | double | Dikdörtgenin genişliğini tutar |
Aşağıdaki örnek kod, dikdörtgen sınıfını aşırı yükleyerek, iki dikdörtgen nesnesinin toplam alanını hesaplamasını gösterir:
class Rectangle { private: double length; double width; public: Rectangle(double l, double w) { length = l; width = w; } double getLength() { return length; } double getWidth() { return width; } void setLength(double l) { length = l; } void setWidth(double w) { width = w; } Rectangle operator+(const Rectangle& r) { Rectangle result; result.setLength(length + r.length); result.setWidth(width + r.width); return result; }}; int main() { Rectangle rect1(7, 4); Rectangle rect2(4, 6); Rectangle rect3 = rect1 + rect2; cout << Length: << rect3.getLength() << ", " << Width: << rect3.getWidth() << endl; return 0;}Bu örnekte, Rectangle sınıfı aşırı yüklendi ve + operatörü, iki dikdörtgeni birleştirerek yeni bir dikdörtgen nesnesi oluşturur. Ardından, yeni dikdörtgenin uzunluğu ve genişliği ekrana yazdırılır.
Örnek Kod:
Bu örnek kodda, bir dikdörtgen sınıfı örneği oluşturulmuş ve aşırı yükleme kullanılarak iki farklı dikdörtgenin toplamı alınmıştır. Aşırı yükleme operatörü (+) kullanılarak, iki dikdörtgen nesnesinin uzunluk ve genişlikleri toplanmıştır. İlgili kod şu şekildedir:
| Veri Türü | Değişken Adı | Açıklama |
|---|---|---|
| Rectangle | r | Toplanacak olan diğer dikdörtgen nesnesi |
Kodda görüleceği üzere, aşırı yükleme operatörü ile daha önce tanımlanan Rectangle sınıfına operator+ eklenerek kullanılmıştır. Operator+ fonksiyonu, yeni bir dikdörtgen örneği oluşturmak için kullanılmıştır. Tüm uzunluk ve genişlik değerleri toplandıktan sonra, sonuç olarak yeni bir dikdörtgen nesnesi döndürülmüştür.
Bu örnekteki aşırı yüklenmiş operatör, kullanıcılara dikdörtgenlerin toplam uzunluk ve genişliklerini hesaplama olanağı sağlar. Örneğin, bir oda için iki farklı dikdörtgenin alanları (pencere ve kapı) bulunduğunda, kullanıcılar aşırı yükleme sayesinde bu iki dikdörtgenin alanını basit bir şekilde toplayabilirler.
Rectangle result;Bu örnekte, bir dikdörtgen sınıfı örneği oluşturulup, iki dikdörtgenin birleşik bir dikdörtgen hesaplaması yapılmaktadır. Bu işlem, iki dikdörtgenin uzunluk ve genişlik değerlerini toplayarak gerçekleştirilir. Hesaplama sonucu, yeni bir dikdörtgen nesnesi oluşturulur ve sonuçlar bu nesneye atanır. Aşağıdaki kod örneğinde, bu hesaplama operator+ fonksiyonu kullanılarak gerçekleştirilmiştir:
Rectangle operator+(const Rectangle& r) { Rectangle result; result.setLength(length + r.length); result.setWidth(width + r.width); return result; }Bu kodda, operator+ fonksiyonu, dikdörtgen nesnesi için aşırı yükleme olarak tanımlanmıştır. İki dikdörtgen nesnesi toplanarak, sonuçlar yeni bir dikdörtgen oluşturmak için kullanılmıştır. İlk olarak, yeni bir dikdörtgen nesnesi oluşturulur ve sonuçlar bu nesneye atılır. Son olarak, bu yeni dikdörtgen nesnesi döndürülür ve sonuçlar kullanıcıya gösterilir.
result.setLength(length + r.length);Yukarıdaki örnek kod, aşırı yüklenmiş '+' operatörünü kullanarak iki farklı dikdörtgen sınıf örneğini toplamaktadır. Bu işlem 'length' ve 'width' özelliklerine göre gerçekleştirilmektedir. 'result.setLength(length + r.length)' ifadesi, 'result' nesnesinin 'length' özelliğine, iki dikdörtgen sınıf örneğinin 'length' özelliklerinin toplamı olan 'length + r.length' değerini atar. Benzer şekilde, 'result.setWidth(width + r.width)' ifadesi, 'result' nesnesinin 'width' özelliğine, iki dikdörtgen sınıf örneğinin 'width' özelliklerinin toplamı olan 'width + r.width' değerini atar. Son olarak, 'result' nesnesi, toplama işleminin sonucu olarak döndürülür.
result.setWidth(width + r.width);Bu kod satırı, aritmetik operatörlerin aşırı yüklenmesiyle ilgilidir ve sınıf nesnelerinin matematiksel işlemleri için kullanılabilir. Bu örnekte, bir dikdörtgen sınıf örneği oluşturulup, diğer bir dikdörtgenin genişliğiyle toplanır. Böylece, iki dikdörtgen nesnesinin birleşik dikdörtgeni hesaplanabilir.
| Aritmetik Operatör | Anlamı |
|---|---|
| + | Toplama |
| - | Çıkarma |
| * | Çarpma |
| / | Bölme |
Bu kod çıktısı, bir dikdörtgen sınıfı örneği için şu şekilde olabilir:
Dikdörtgen 1: Boy: 5 En: 3Dikdörtgen 2: Boy: 4 En: 2Birleşik Dikdörtgen: Boy: 9 En: 5
Rectangle operator+(const Rectangle& r) { Rectangle result; result.setLength(length + r.length); result.setWidth(width + r.width); return result; }return result;Bu örnek kodda, bir dikdörtgen sınıfı örneği oluşturulup, birleşik bir dikdörtgen hesaplaması yapılmıştır. Aritmetik operatörler olan (+) ile bu işlem gerçekleştirilirken, aşırı yükleme özelliği kullanılmıştır. İlk önce bir dikdörtgen nesnesi oluşturulmuş ve daha sonra (+) operatörü kullanılarak, bu nesne ile diğer dikdörtgen nesnesi toplanarak yeni bir dikdörtgen sınıf örneği elde edilmiştir. Bu işlem sonucunda, iki dikdörtgenin uzunluğu ve genişliği toplanarak yeni bir dikdörtgen oluşturulmuştur. Daha sonra, bu yeni dikdörtgen nesnesi oluşturulmuş ve sonuç olarak ("return result;"), bu nesne döndürülmüştür.
}Bir C++ sınıfı içinde, aynı operatörün farklı türdeki veriler üzerinde farklı işlemler yapmasını sağlayabilirsiniz. Operatör aşırı yüklemesi, önemli bir nesne yönelimli programlama tekniğidir. Bu teknik, C++ sınıflarının verimliliği, işlevselliği ve okunabilirliği açısından büyük bir fayda sağlar.
C++ dilinde en yaygın aşırı yüklenen operatörler arasında atama, karşılaştırma, aritmetik ve akım operatörleri bulunur. Aşırı yükleme, sınıf nesneleri arasında matematiksel işlemler yapmak, nesneleri dosyalara veya ekrana yazdırmak gibi işlemleri daha özelleştirilmiş hale getirmek için kullanılır.
Karşılaştırma operatörleri ve atama operatörleri, nesneler arasında veri atama ve karşılaştırma işlemlerini gerçekleştirmek için aşırı yüklenebilir. Aritmetik operatörler, farklı veri tiplerini içeren nesneler arasında matematiksel işlemler yapmak için kullanılabilir. Akım operatörleri, sınıf nesnelerinin içerdiği verileri dosyalara veya ekrana yazdırmak için aşırı yüklenebilir.
Akım Operatörleri
C++ sınıfları, programcıların farklı veri türleri üzerinde belirli işlemler gerçekleştirmek için operatör aşırı yüklemeleri sağlar. Bu nedenle, farklı operatör türleri için farklı aşırı yüklemeler yapılır. Bununla birlikte, akım operatörleri (<<, >>), sınıfın nesnesi için aşırı yüklenebilir. Bu operatörler sayesinde, nesnelerin değerleri ekrana ve/veya dosyalara yazdırılabilir.
Akım operatörleri, çoğu zaman yazma ve okuma işlevleri için kullanılır. Bu nedenle, bu operatörlerin yüklenmesi, değerlerin istenen yere yazdırılmasını kolaylaştırır. Örneğin, bir öğrenci sınıfı örneğindeki öğrencinin bilgilerini, akım operatörü kullanarak ekrana yazdırabilirsiniz. Bu, kodun daha anlaşılır hale gelmesini ve programcıya zaman kazandırmasını sağlar.
Akım operatörleri hakkında daha detaylı bilgi için, aşağıdaki örneği inceleyebilirsiniz:
| Akım Operatörü | Görevi |
|---|---|
| >> | Değerleri bir sınıf nesnesine okur |
| << | Değerleri bir sınıf nesnesinden ekrana veya dosyaya yazar |
Akım operatörü, kullanıcının yalnızca bir objeyi okur veya bir objeyi yazdırmasına izin verir. Aşağıda bir öğrenci sınıfı örneğindeki akım operatörünün nasıl kullanılabileceğine dair bir kod parçası verilmiştir:
friend ostream& operator<<(ostream& output, const Student& s) { output << endl; Name: << s.name << endl; output << Grade: << s.grade << endl; return output;}Bu örnek kod parçasında, ostream nesnesi, ana fonksiyonun dışında bir işlev olarak tanımlanmıştır. Bu nesne, öğrenci sınıfının özelliklerini görüntülemeniz için tarayıcınızda bir çıktı sağlar. Burada, akım operatörü, öğrenci sınıfı objesi ve ostream nesnesi parametreleriyle kullanılmıştır. Bu, öğrenci sınıfının objelerinin, işlevin sağlanan akış nesnesine yazdırılabileceği ve sonuçların okunabileceği anlamına gelir.
Bu nedenle, C++ dilindeki akım operatörlerinin aşırı yüklenmesi, kodun okunabilirliğini ve anlaşılabilirliğini arttırır. Bu sayede, bir sınıf örneği üzerindeki verileri ekrana veya dosyaya yazdırmak daha kolay hale gelir.
Örnek:
Bir öğrenci sınıf örneği, sınıftaki öğrencilerin bilgilerini tutmak için oluşturulabilir. Bu sınıfın örnekleri, öğrencilerin isimleri ve notları gibi bilgileri içerebilir. Bu bilgileri ekrana yazdırmak için, akım operatörleri aşırı yüklenebilir. Aşağıdaki örnek kodda, << operatörü aşırı yüklendi ve öğrenci sınıfının örneği ekrana yazdırıldı:
class Student {public: string name; int grade; friend ostream& operator<<(ostream& output, const Student& s) { output << "Name: " << s.name << endl; output << "Grade: " << s.grade << endl; return output; }};int main() { Student s; s.name = "John Doe"; s.grade = 90; cout << s; return 0;}Bu örnek kodda, bir öğrenci sınıf örneği oluşturuldu ve ismi "John Doe" ve notu 90 olarak ayarlandı. << operatörü, öğrencinin bilgilerini ekrana yazdırmak için kullanıldı. Çıktı, aşağıdaki gibidir:
Name: John DoeGrade: 90Bu örnekte görüldüğü gibi, akım operatörleri aşırı yüklendiğinde, sınıf nesnesinin bilgileri ekrana yazdırılabilir. Bu, öğrenci sınıfının örneği için de geçerlidir.
Örnek Kod:
Bu örnekte, Akım operatörü aşırı yüklenerek bir öğrenci sınıf örneğinin bilgileri ekrana yazdırılıyor. İşlem için, friend anahtar kelimesi kullanılarak operatör aşırı yükleniyor. Bu anahtar kelimesi sınıfın özel üye fonksiyonlarına başka bir sınıftan erişim sağlayabilmek için kullanılıyor.
Aşağıdaki örnek kodda, << operatörü aşırı yüklenerek bir ostream nesnesine Student sınıfının değerleri yazdırılıyor. Fonksiyon, parametre olarak bir ostream ve bir const Student nesnesini alıyor. Akım operatörü, öğrenci adını ve notunu yazdırıyor ve output nesnesini döndürüyor.
friend ostream& operator<<(ostream& output, const Student& s) { output << "Name: " << s.name << endl; output << "Grade: " << s.grade << endl; return output;}Akım operatörü aşırı yüklemesi, özellikle veri dosyaları için yapılacak yazma işlemlerinde oldukça kullanışlıdır. Bu sayede, programcılar özel sınıfları ve nesneleri yazdırabilirler.
output <<output <<Aşırı yüklenen akım operatörü (<<), sınıf nesnesi için ayrı bir işleve ihtiyaç duymaksızın, istenildiği kadar çağrılabilir. Bir nesnenin akış değişkeni (cout gibi) ile akışları bir bileşen gibi kullanmayı sağlar. Burada özellikle bazı operatörler sınıfı gösteren işaret yapısı, diğer operatörler ise çıkış ya da giriş değişkenleri ile kullanılır. Ayrıca, yapılan aşırı yüklemeyle sınıf nesnesinin verileri bir dosyaya ya da ekrana yazdırılabilir. Örneğin, bir öğrenci sınıf nesnesinin bilgileri, akım operatörü aşırı yüklenerek ekrana yazdırılabilir.
friend ostream& operator<<(ostream& output, const Student& s) {
output << "Name: " << s.name << endl;
output << "Grade: " << s.grade << endl;
return output;
}
Bir sınıfın en temel özelliklerinden biri, nesnesinin bir isme sahip olmasıdır. İsim, o sınıf örneğinin benzersiz olduğunu gösterir. Sınıfın özellikleri gibi isim de özelleştirilebilir ve değiştirilebilir. Her örneğin farklı bir ismi olmalıdır ve bu isim kullanıcıya nesneyi tanımada ve ayırt etmede yardımcı olur.
<< s.name << endl;Bu örnek kodda, öğrenci sınıfına ait iki öğrenci nesnesi, notlarına göre karşılaştırılabilir hale getirilmiştir. Operatör aşırı yüklemesi sayesinde, karşılaştırma operatörü (>) iki öğrenci nesnesi arasındaki notları karşılaştıran bir işleme dönüştürülmüştür.
Aynı şekilde, atama operatörü (=) sayesinde, bir öğrenci nesnesinin değerleri başka bir öğrenci nesnesine atanan ve böylece kopyalanabilen bir işleme dönüştürülebilir.
Aritmetik operatörlerle, farklı sınıf nesneleri arasında matematiksel işlemler yapılabilir. Örneğin, dikdörtgen sınıfı örneği oluşturulup, birleşik bir dikdörtgen hesaplaması yapılabilmektedir.
Akım operatörleri ile de sınıf nesnesinin değerleri dosyalara veya ekrana yazdırılabilir. Örneğin, bir öğrenci sınıf örneğinin bilgileri, ekrana yazdırılabilir.
output <Aşırı yükleme özellikle C++ sınıfları için son derece yararlı bir özelliktir. Ancak, aşırı yükleme işlemini yaparken belirli bir dikkat ve özen göstermek önemlidir. Öncelikle, aşırı yüklenmiş bir operatörün yapısını belirlerken, operatörün orijinal yapısını dikkate alarak mantıklı bir yapı kurmaya özen gösterin.
Ayrıca, aşırı yüklenmiş bir operatörü kullanırken, operatörün işlevselliğine karşılık gelen mantıklı bir sonuca ulaşmanız gerekir. Bunu yaparken aritmetik operatörler için matematiksel hesaplamalar önceden yapılmalı, atama operatörleri için uygun bellek ayırma ve değişken atamaları yapılmalıdır.
Gerçekleştirilecek işlemin türüne ve yapısına göre uygun verilerin kullanılması, ayrıca operatör aşırı yüklemesi yaparken oldukça dikkat edilmesi gereken önemli bir noktadır. Bu şekilde, aşırı yüklenmiş operatörlerin kullanımı, sınıfların daha verimli ve işlevsel olmasını sağlar.
Grade:Bir öğrenci sınıfında, öğrencilerin notları sıklıkla saklanır ve işlenir. Bu nedenle, notlarınızın doğru bir şekilde tutulması önemlidir. Notların saklanması için sınıfa veri üyeleri eklenir ve bu üyelerin erişimi için aşırı yüklü operatörler kullanılır. Bu operatörler arasında en yaygın olanları, karşılaştırma operatörleri (==, !=, <, >, <=, >=) ve atama operatörü (=) dur. Ayrıca, matematiksel işlemleri gerçekleştirmek için aşırı yüklü aritmetik operatörler (+, -, *, /) kullanılablir. Öğrenci notları, öğrencilerin ilerlemesini izlemek ve nihai sınıf atlamalarını belirlemek için kritik bir unsurdur. Bu nedenle işlem sırasında doğru sonuçların üretmesi önemlidir.
Student sınıfındaki grade üyesi, öğrenci notlarını saklamak için bir veri üyesidir. Bu üye, geçerli bir notun saklanabileceği bir veri türüne sahip olmalıdır. Ayrıca, notlar aşırı yüklü operatörler kullanılarak işlenir. Örneğin, bir öğrencinin notu, başka bir öğrencinin notuyla karşılaştırılabilir. Bunu yapmak için, '>' ve '<' işaretleri gibi karşılaştırma operatörleri aşırı yüklenebilir. Öğrenci sınıfında, 'grade' üyesine sahip öğrenci nesnelerinde karşılaştırmalar yapmak için bu operatörler kullanılır. Aynı şekilde, bir öğrencinin notu, bir başka öğrenci nesnesine atandığında, atama operatörü aşırı yüklenebilir. Bu, öğrenci notlarını başka bir diziye veya veri yapısına kopyalamayı kolaylaştırır.
Genel olarak, operatör aşırı yükleme, C++ sınıflarında sıkça kullanılan bir tekniktir. Bu teknik, nesnelerin cebirsel işlem, karşılaştırma ve akış işlemlerini daha kolay hale getirir. Ayrıca, sınıftaki veri üyelerini işlemenin doğru ve etkili bir yolu sağlar. C++ sınıflarında operatör aşırı yükleme konusunda bilgi sahibi olan bir yazılımcı olarak, bu teknikleri öğrenmek ve kullanmak, programlama yeteneklerinizi geliştirmenize yardımcı olacak ve öğrencilerin notlarını doğru bir şekilde saklamak ve işlemek için faydalı olacaktır.
<< s.grade << endl;Operatörler, C++ programlama dilinde en yaygın kullanılan yapıdır. Bu operatörler, farklı tiplerdeki veriler üzerinde farklı işlemler gerçekleştirirler. Operatör aşırı yükleme ise, var olan bir operatörün farklı tiplerdeki veriler üzerinde farklı işlemler gerçekleştirmesine olanak tanır. Örneğin, '+' operatörü normalde sayılar üzerinde kullanılabilirken, aşırı yüklenerek string'ler üzerinde de kullanılabilir hale getirilebilir.
C++ programlama dilindeki bir sınıf için, operatör aşırı yükleme işlemi gerçekleştirmek oldukça kullanışlıdır. Sınıf nesneleri arasında karşılaştırma işlemleri, veri atama işlemleri, aritmetik işlemler ve nesneyi akışa yazma işlemleri, aşırı yükleme ile gerçekleştirilebilir.
Hangi operatörlerin aşırı yüklenebileceği konusu önemlidir. C++ dilinde en yaygın aşırı yüklenen operatörler arasında atama, karşılaştırma, aritmetik ve akım operatörleri bulunur. Karşılaştırma ve atama operatörleri, özel bir sınıf için yüklenirken, aritmetik ve akım operatörleri, sınıf için ayrı ayrı tanımlanır.
return output;'return output', akım operatörleri aşırı yüklemesi yapılırken en önemli adımlardan biridir. Bu adım, belirli bir işlem gerçekleştirmek için kullanılan geri dönüş değerinin belirlenmesini sağlar. Ayrıca output parametresi burada kullanıcının belirttiği akım nesnesine yazdırılır. Yazdırma işlemi için akım nesnesi, cout parametresi yerine belirtilir. Özellikle sınıflarla çalışırken, akım operatörleri, belirli bir sınıfın tercih edilen bir formatla yazdırılmasını sağlayabilir. Bu sayede kullanıcılar, sınıf bilgilerini daha iyi anlayabilirler.
}Aşağıdaki örnek kod, iki Öğrenci nesnesinin en yüksek notuna sahip olanın adını döndürür.
| Kod: |
|---|
| Student highestdsu = s1 >s2 ? s1 : s2; |
Bu kod, bir karşılaştırma operatörü olan > işleci ile iki öğrenci nesnesinin notlarını karşılaştırır ve en yüksek notlu öğrencinin nesnesini seçer.
Yukarıdaki örnek, sınıflarda operatör aşırı yüklemeyi aritmetik, atama, karşılaştırma ve akım işlemleri için kullanabileceğimizi net bir şekilde göstermektedir. Bu özellik, C++ dilinin verimliliğini artırır ve programcılara daha fazla esneklik sağlar.