C++ dilinin başlangıcı 1983'te, kısa bir süre sonra gerçekleşti. 'Bjare Stroustrup' Operatör aşırı yüklemesi gibi bazı ek özelliklerle birlikte C dilindeki sınıflarla çalıştı. Kullanılan dosya uzantıları '.c' ve '.cpp'dir. C++ genişletilebilirdir ve platforma bağlı değildir ve Standart Şablon Kitaplığı'nın kısaltması olan STL'yi içerir. Bu nedenle, temel olarak bilinen C++ dili, nesne dosyalarını oluşturmak için bir araya derlenmiş kaynak dosyaya sahip, bir bağlayıcı ile birleştirildiğinde çalıştırılabilir bir program üreten derlenmiş bir dil olarak bilinir.

Öte yandan, seviyesi hakkında konuşursak, sürücüler veya çekirdekler gibi düşük seviyeli programlamanın ve ayrıca oyunlar, GUI veya masaüstü uygulamaları gibi daha yüksek seviyeli uygulamaların avantajını yorumlayan orta seviyedir. Ancak sözdizimi hem C hem de C++ için hemen hemen aynıdır.

C++ Dilinin Bileşenleri:

#include

Bu komut, 'cout' komutunu içeren bir başlık dosyasıdır. Kullanıcının ihtiyaç ve tercihlerine bağlı olarak birden fazla başlık dosyası olabilir.

int ana()

Bu ifade, her C++ programı için bir ön koşul olan ana program işlevidir, yani bu ifade olmadan herhangi bir C++ programı çalıştırılamaz. Burada 'int', işlevin döndürdüğü veri türünü anlatan dönüş değişkeni veri türüdür.

Beyanname:

Değişkenler bildirilir ve bunlara isimler atanır.

Sorun bildirimi:

Bu, bir programda önemlidir ve bir 'while' döngüsü, 'for' döngüsü veya uygulanan başka herhangi bir koşul olabilir.

Operatörler:

Operatörler C++ programlarında kullanılır ve bazıları koşullara uygulandıkları için çok önemlidir. Birkaç önemli operatör &&, ||, !, &, !=, |, &=, |=, ^, ^=.

C++ Giriş Çıkışı:

Şimdi, C++'daki giriş ve çıkış yeteneklerini tartışacağız. C++'da kullanılan standart kitaplıkların tümü, bir bayt dizisi biçiminde gerçekleştirilen veya normalde akışlarla ilgili olan maksimum giriş ve çıkış yetenekleri sağlar.

Giriş akışı:

Baytların cihazdan ana belleğe aktarılması durumunda, giriş akışıdır.

Çıkış akışı:

Baytlar ters yönde akıyorsa, çıkış akımıdır.

C++'da giriş ve çıkışı kolaylaştırmak için bir başlık dosyası kullanılır. Örneğin güveç ve ayar hassasiyeti gibi yöntemler sağlayan olarak yazılmıştır. Giriş ve çıkış komutları cin, cout, cerr ve clog'dur. Burada 'cin' standart girişi, 'cout' ise ifadeleri ekranda görüntülemek için akış ekleme operatörleri (<<) ile kullanılan standart çıkış cihazını belirtir.

Örnek:

Bir karakter tipi dize kullanarak bir dize mesajı görüntüleyeceğiz.

İlk satıra, bir C++ programının yürütülmesi için ihtiyaç duyabileceğimiz neredeyse tüm temel kitaplıklara sahip olan 'iostream'i dahil ediyoruz. Sonraki satırda, tanımlayıcılar için kapsam sağlayan bir ad alanı bildiriyoruz. Ana işlevi çağırdıktan sonra, dize mesajını saklayan ve 'cout' onu birleştirerek görüntüleyen bir karakter tipi dizisi başlatıyoruz. Metni ekranda görüntülemek için 'cout' kullanıyoruz. Ayrıca, bir karakter dizisini depolamak için karakter veri tipi dizisine sahip bir 'A' değişkeni aldık ve ardından 'cout' komutunu kullanarak statik mesaj boyunca her iki dizi mesajını da ekledik.

Üretilen çıktı aşağıda gösterilmiştir:

Örnek:

Bu durumda, kullanıcının yaşını basit bir dize mesajında ​​temsil edeceğiz.

İlk adımda kütüphaneyi dahil ediyoruz. Bundan sonra, tanımlayıcıların kapsamını sağlayacak bir ad alanı kullanıyoruz. Bir sonraki adımda, ana() işlev. Bundan sonra, age'yi bir 'int' değişkeni olarak başlatıyoruz. Basit dize mesajının girişi için 'cin' komutunu ve çıktısı için 'cout' komutunu kullanıyoruz. 'cin' kullanıcıdan yaş değerini girer ve 'cout' bunu diğer statik mesajda görüntüler.

Bu mesaj, program çalıştırıldıktan sonra kullanıcının yaş alabilmesi için ekranda gösterilir ve ardından ENTER'a basın.

Örnek:

Burada, 'cout' kullanarak bir dizenin nasıl yazdırılacağını gösteriyoruz.

Bir dize yazdırmak için, önce bir kitaplık ve ardından tanımlayıcılar için ad alanı ekleriz. bu ana() fonksiyon denir. Ayrıca, ekranda statik mesajı görüntüleyen ekleme operatörüyle 'cout' komutunu kullanarak bir dize çıktısı yazdırıyoruz.

C++ Veri Türleri:

C++'daki veri türleri, C++ programlama dilinin temeli olduğu için çok önemli ve yaygın olarak bilinen bir konudur. Benzer şekilde, kullanılan herhangi bir değişken, belirtilen veya tanımlanmış bir veri türünde olmalıdır.

Tüm değişkenler için, geri yüklenmesi gereken veri türünü sınırlamak için bildirimden geçerken veri türünü kullandığımızı biliyoruz. Veya, veri türlerinin her zaman bir değişkene kendisinin depoladığı veri türünü söylediğini söyleyebiliriz. Her bir değişken tanımladığımızda, derleyici, her veri türü farklı bir bellek depolama kapasitesine sahip olduğundan, belirtilen veri türüne göre belleği tahsis eder.

C++ dili, programcının ihtiyaç duyabileceği uygun veri türünü seçebilmesi için veri türlerinin çeşitliliğine yardımcı olur.

C++, aşağıda belirtilen veri türlerinin kullanımını kolaylaştırır:

1. Kullanıcı tanımlı veri türleri
2. Türetilmiş veri türleri
3. Yerleşik veri türleri

Örneğin, birkaç yaygın veri türünü başlatarak veri türlerinin önemini göstermek için aşağıdaki satırlar verilmiştir:

Birkaç yaygın veri türü: hangi boyutu belirledikleri ve değişkenlerinin hangi tür bilgileri depolayacağı aşağıda gösterilmiştir:

• Char: Bir bayt boyutunda tek bir karakter, harf, sayı veya ASCII değerlerini saklar.
• Boolean: 1 bayt boyutunda, değerleri true veya false olarak saklar ve döndürür.
• Int: 2 veya 4 bayt boyutunda, ondalıksız tam sayıları saklar.
• Kayan nokta: 4 bayt boyutunda, bir veya daha fazla ondalıklı kesirli sayıları saklar. Bu, 7 ondalık basamağa kadar saklamak için yeterlidir.
• Çift kayan nokta: 8 bayt boyutunda, bir veya daha fazla ondalıklı kesirli sayıları da saklayacaktır. Bu, 15 ondalık basamağa kadar saklamak için yeterlidir.
• Void: Belirli bir boyutu olmayan bir boşluk, değersiz bir şey içerir. Bu nedenle boş değer döndüren işlevler için kullanılır.
• Geniş karakter: Genellikle 2 veya 4 bayt uzunluğunda 8 bitten büyük bir boyuta sahip wchar_t ile temsil edilir, char'a benzer ve bu nedenle bir karakter değeri de depolar.

Yukarıda bahsedilen değişkenlerin boyutu, programın veya derleyicinin kullanımına bağlı olarak farklılık gösterebilir.

Örnek:

Yukarıda açıklanan birkaç veri türünün tam boyutlarını verecek basit bir C++ kodu yazalım:

Bu kodda, kitaplığını entegre ediyoruz. Bundan sonra, 'ad alanını' kullanıyoruz. Bir sonraki satırda, ana() programda belirtilen tüm veri türlerinin boyutlarını yazdıracak bir 'cout' komutu kullandığımız işlev. Değişkenlerin boyutunu bulmak için, boyutu() yöntem.

Çıktı, şekilde gösterildiği gibi bayt olarak alınır:

Örnek:

Burada iki farklı veri türünün boyutunu ekleyeceğiz.

İlk olarak, tanımlayıcılar için bir 'standart ad alanı' kullanan bir başlık dosyası ekliyoruz. Daha sonra, ana() Bu ikisinin boyutları arasındaki farkı kontrol etmek için önce 'int' değişkenini ve ardından bir 'double' değişkenini başlattığımız işlev çağrılır. Daha sonra, boyutları kullanılarak birleştirilir. boyutu() işlev. Çıktı, 'cout' ifadesi ile görüntülenir.

Burada belirtilmesi gereken bir terim daha var ve bu 'Veri değiştiriciler' . Ad, belirli bir veri türünün derleyicinin ihtiyacına veya gereksinimine göre destekleyebileceği uzunluklarını değiştirmek için yerleşik veri türleri boyunca 'veri değiştiricilerin' kullanıldığını gösterir.

Aşağıdakiler, C++'da erişilebilen veri değiştiricileridir:

1. imzalı
2. imzasız
3. Uzun
4. Kısa

Değiştirilen boyut ve ayrıca yerleşik veri türlerinin uygun aralığı, veri türü değiştiricileri ile birleştirildiğinde aşağıda belirtilmiştir:

• Kısa int: 2 bayt boyutunda, -32.768'den 32.767'ye kadar çeşitli modifikasyonlara sahiptir.
• Unsigned short int: 2 bayt boyutunda, 0'dan 65.535'e kadar değişiklik aralığına sahiptir.
• Unsigned int: 4 bayt boyutunda, 0'dan 4,294,967,295'e kadar değişiklik aralığına sahiptir.
• Int: 4 bayt boyutunda, -2.147.483.648 ile 2.147.483.647 arasında değişiklik aralığına sahiptir.
• Uzun int: 4 bayt boyutunda, -2.147.483.648 ile 2.147.483.647 arasında değişiklik aralığına sahiptir.
• Unsigned long int: 4 bayt boyutunda, 0'dan 4.294.967.295'e kadar değişiklik aralığına sahiptir.
• Long long int: 8 bayt boyutunda, –(2^63) ile (2^63)-1 arasında bir değişiklik aralığına sahiptir.
• Unsigned long long int: 8 bayt boyutunda, 0 ile 18,446,744,073,709,551,615 arasında değişiklik aralığına sahiptir.
• İmzalı karakter: 1 bayt boyutunda, -128'den 127'ye kadar bir dizi modifikasyona sahiptir.
• İmzasız karakter: 1 bayt boyutunda, 0 ile 255 arasında bir değişiklik aralığına sahiptir.

C++ Numaralandırma:

C++ programlama dilinde 'Numaralandırma', kullanıcı tanımlı bir veri türüdür. Numaralandırma 'olarak bildirilir Sıralama' C++'da. Programda kullanılan herhangi bir sabite belirli isimler atamak için kullanılır. Programın okunabilirliğini ve kullanılabilirliğini artırır.

Sözdizimi:

C++'da numaralandırmayı aşağıdaki gibi bildiririz:

C++'da Numaralandırmanın Avantajları:

Enum aşağıdaki şekillerde kullanılabilir:

• Switch case ifadelerinde sıklıkla kullanılabilir.
• Yapıcıları, alanları ve yöntemleri kullanabilir.
• Başka bir sınıfı değil, yalnızca 'enum' sınıfını genişletebilir.
• Derleme süresini artırabilir.
• Geçilebilir.

C++'da Numaralandırmanın Dezavantajları:

Enum'un ayrıca birkaç dezavantajı vardır:

Bir ad bir kez numaralandırılırsa, aynı kapsamda tekrar kullanılamaz.

Örneğin:

Enum ileri bildirilemez.

Örneğin:

İsimlere benziyorlar ama tamsayılar. Böylece otomatik olarak başka herhangi bir veri türüne dönüşebilirler.

Örneğin:

Örnek:

Bu örnekte, C++ numaralandırmanın kullanımını görüyoruz:

Bu kod yürütmede öncelikle #include ile başlıyoruz. , C++'daki zengin kitaplıklardan biridir. Yerleşik bir kütüphanedir. Giriş ve Çıkış veri akışlarını içerir . Bundan sonra Standart ad alanını kullanırız. Daha sonra 'enum' adını Konu olarak belirledik ve Matematik, İngilizce ve Urduca olmak üzere üç konu atadık. Math'a 1 değeri atanır. Amacımız, enum'da belirtilen Subject değerlerini yazdırmaktır. Sonra, biz çağırırız ana() işlev. İçinde ana() cout<< var, burada 'c' 'karakter' ve out 'çıktı' anlamına gelir. 'Cout' çıktıyı görüntülemek için kullanılır . << ekleme operatörünü gösterir. ‘cout<<’ kullanarak enum değerlerini yazdırıyoruz. Ardından, 'return 0' komutunu kullanacağız. Bu komut, değerler biçimindeki sonucu döndürür.

İşte yürütülen programın sonucumuz:

Gördüğünüz gibi Subject: Math, Urdu, English; yani 1,2,3.

Örnek:

Enum ile ilgili kavramlarımızı temizlediğimiz başka bir örnek:

Bu programda, başlık dosyasını entegre ederek başlıyoruz. Yerleşik bir kütüphanedir. Giriş ve Çıkış veri akışlarını içerir. Bundan sonra, Standart ad alanını kullanmalıyız. Ardından, oyuncular olan sabitlere enum değerleri atadık. Hedefimiz kimin üzerinde olduğunu göstermek. Daha sonra, bizim ana() işlev. İçinde ana() fonksiyonuna iki sabit atadık: değeri 'bowler1' enum değişkenine 20 olan Shadab; ve değeri 'bowler2' enum değişkenine göre 25 olan Afridi.

Bir if-else ifadesi kullanmalıyız . Ayrıca karşılaştırma operatörünü 'if' ifadesinin içinde kullandık, bu da 'melon2'nin 'melon1'den büyük olup olmadığını karşılaştırdığımız anlamına gelir. Ardından, 'if' bloğu yürütülür, bu da Afridi'nin bittiği anlamına gelir. Ardından çıktıyı görüntülemek için 'cout<<' girdik. İlk olarak, 'Bitti' ifadesini yazdırıyoruz. Ardından, 'bowler2' değeri. Değilse, else bloğu çağrılır, bu da Shadab'ın bittiği anlamına gelir. Ardından 'cout<<' komutunu uygulayarak 'Bitti' ifadesini ekrana getiriyoruz. Ardından, 'bowler1' değeri.

If-else ifadesine göre elimizde 25'in üzerinde olan Afridi'nin değeri var. Bu, 'bowler2' enum değişkeninin değerinin 'bowler1' değerinden büyük olduğu anlamına gelir, bu nedenle 'if' ifadesi yürütülür.

C++ Aksi takdirde, Değiştir:

C++ programlama dilinde, programın akışını değiştirmek için 'if deyimi' ve 'switch deyimi' kullanıyoruz. Bu ifadeler, sırasıyla belirtilen ifadelerin gerçek değerine bağlı olarak programın uygulanması için birden fazla komut seti sağlamak için kullanılır. Çoğu durumda, 'if' deyimine alternatif olarak operatörleri kullanırız. Yukarıda belirtilen tüm bu ifadeler, karar verici veya koşullu ifadeler olarak bilinen seçim ifadeleridir.

'Eğer' ifadesi:

Bu ifade, herhangi bir programın akışını değiştirmek istediğinizde belirli bir koşulu test etmek için kullanılır. Burada bir koşul doğruysa program yazılı yönergeleri yürütür, koşul yanlışsa yalnızca sonlandırılır. Bir örnek düşünelim;

Bu, bir 'int' değişkenini 10 olarak başlattığımız basit 'if' ifadesidir. Ardından, kullanıcıdan bir değer alınır ve 'if' deyiminde çapraz kontrol edilir. 'if' ifadesinde uygulanan koşulları sağlıyorsa, çıktı görüntülenir.

Seçilen rakam 40 olduğu için çıktı mesajdır.

'Eğer-else' ifadesi:

'if' ifadesinin genellikle işbirliği yapmadığı daha karmaşık bir programda, 'if-else' ifadesini kullanırız. Verilen durumda, uygulanan koşulları kontrol etmek için 'if- else' ifadesini kullanıyoruz.

İlk olarak, değeri kullanıcıdan alınan 'x' adında bir veri tipi 'int' değişkeni tanımlayacağız. Şimdi, kullanıcı tarafından girilen tamsayı değeri 2 ise, çıktısı istenen olacak ve basit bir 'GÜZEL DENEYİN' mesajı görüntülenecek bir koşul uyguladığımız 'if' ifadesi kullanılıyor. Aksi takdirde girilen sayı 2 değilse çıktı farklı olacaktır.

Kullanıcı 2 sayısını yazdığında aşağıdaki çıktı gösterilir.

Kullanıcı 2 dışında herhangi bir sayı yazdığında aldığımız çıktı:

If-else-if ifadesi:

İç içe if-else-if ifadeleri oldukça karmaşıktır ve aynı kodda birden çok koşul uygulandığında kullanılır. Başka bir örnek kullanarak bunun üzerinde düşünelim:

Burada, başlık dosyası ve ad alanını entegre ettikten sonra, 'm' değişkeninin değerini 200 olarak başlattık. Daha sonra 'm' değeri kullanıcıdan alınır ve ardından programda belirtilen çoklu koşullarla çapraz kontrol edilir.

Burada kullanıcı 195 değerini seçti. Bu nedenle çıktı, bunun 'm'nin gerçek değeri olduğunu gösteriyor.

Anahtar deyimi:

Birden çok değerden oluşan bir listeye eşitse test edilmesi gereken bir değişken için C++'da bir 'switch' ifadesi kullanılır. 'Switch' ifadesinde, koşulları farklı durumlar şeklinde tanımlarız ve tüm vakalar, her bir vaka ifadesinin sonunda yer alır. Birden çok vaka, uygun koşullara ve onlara, switch ifadesini sonlandıran ve hiçbir koşulun desteklenmemesi durumunda varsayılan bir ifadeye hareket eden break ifadeleriyle uygulanan ifadelere sahiptir.

Anahtar kelime 'kırılma':

Switch ifadesi 'break' anahtar kelimesini içerir. Kodun sonraki durumda yürütülmesini durdurur. Switch ifadesinin yürütülmesi, C++ derleyicisi 'break' anahtar sözcüğüyle karşılaştığında sona erer ve kontrol, switch ifadesini izleyen satıra geçer. Bir anahtarda break deyimi kullanmak gerekli değildir. Yürütme, kullanılmazsa bir sonraki duruma geçer.

Paylaşılan kodun ilk satırına kütüphaneyi ekliyoruz. Bundan sonra, 'ad alanı' ekliyoruz. biz çağırırız ana() işlev. Ardından, bir karakter veri tipi notunu 'F' olarak bildiriyoruz. Bu not sizin isteğiniz olabilir ve sonuç seçilen durumlar için sırasıyla gösterilecektir. Sonucu almak için switch ifadesini uyguladık.

Not olarak 'F' seçersek, çıktı 'bir dahaki sefere iyi şanslar' olur çünkü notun 'F' olması durumunda yazdırılmasını istediğimiz ifade budur.

Dereceyi X olarak değiştirelim ve ne olduğunu görelim. Not olarak 'X' yazdım ve alınan çıktı aşağıda gösterilmiştir:

Bu nedenle, 'anahtar'daki uygun olmayan durum, işaretçiyi otomatik olarak doğrudan varsayılan ifadeye taşır ve programı sonlandırır.

If-else ve switch deyimlerinin bazı ortak özellikleri vardır:

• Bu ifadeler, programın nasıl yürütüldüğünü yönetmek için kullanılır.
• Her ikisi de bir koşulu değerlendirir ve bu, programın nasıl aktığını belirler.
• Farklı temsil tarzlarına sahip olmalarına rağmen aynı amaç için kullanılabilirler.

If-else ve switch ifadeleri belirli şekillerde farklılık gösterir:

• Kullanıcı, 'switch' durum ifadelerindeki değerleri tanımlarken, kısıtlamalar, 'if-else' ifadelerindeki değerleri belirler.
• Değişikliğin nerede yapılması gerektiğini belirlemek zaman alır, 'if-else' ifadelerini değiştirmek zordur. Öte yandan, kolayca değiştirilebildikleri için 'switch' ifadelerinin güncellenmesi kolaydır.
• Birçok ifadeyi dahil etmek için çok sayıda 'if-else' ifadesi kullanabiliriz.

C++ Döngüleri:

Şimdi, C++ programlamasında döngülerin nasıl kullanılacağını keşfedeceğiz. 'Döngü' olarak bilinen kontrol yapısı bir dizi ifadeyi tekrarlar. Başka bir deyişle, tekrarlayan yapı denir. Tüm ifadeler sıralı bir yapıda aynı anda yürütülür . Öte yandan, belirtilen ifadeye bağlı olarak, koşul yapısı bir ifadeyi yürütebilir veya atlayabilir. Belirli durumlarda bir ifadenin birden fazla kez yürütülmesi gerekebilir.

Döngü Türleri:

Üç döngü kategorisi vardır:

• Döngü için
• Döngü sırasında
• Döngü Yaparken

Döngü için:

Döngü, bir döngü gibi kendini tekrar eden ve sağlanan koşulu doğrulamadığında duran bir şeydir. Bir 'for' döngüsü, birçok kez bir dizi ifade uygular ve döngü değişkeniyle başa çıkan kodu yoğunlaştırır. Bu, bir 'for' döngüsünün, belirli sayıda tekrarlanan bir döngü oluşturmamıza izin veren belirli bir yinelemeli kontrol yapısı türü olduğunu gösterir. Döngü, yalnızca basit bir satırdan oluşan bir kod kullanarak “N” sayıda adımı yürütmemize izin verir. Yazılım uygulamanızda yürütülecek bir 'for' döngüsü için kullanacağımız sözdiziminden bahsedelim.

'for' döngü yürütmesinin sözdizimi:

Örnek:

Burada, bu döngüyü bir 'for' döngüsünde düzenlemek için bir döngü değişkeni kullanıyoruz. İlk adım, döngü olarak belirttiğimiz bu değişkene bir değer atamak olacaktır. Bundan sonra, sayaç değerinden küçük mü yoksa büyük mü olduğunu tanımlamalıyız. Şimdi, döngünün gövdesi yürütülecek ve ayrıca ifadenin doğru olması durumunda döngü değişkeni güncellenecektir. Çıkış koşuluna ulaşana kadar yukarıdaki adımlar sıklıkla tekrarlanır.

• Başlatma İfadesi: İlk başta, bu ifadede döngü sayacını herhangi bir başlangıç ​​değerine ayarlamamız gerekiyor.
• Test İfadesi : Şimdi, verilen ifadede verilen koşulu test etmemiz gerekiyor. Kriterler yerine getirilirse, 'for' döngüsünün gövdesini gerçekleştireceğiz ve ifadeyi güncellemeye devam edeceğiz; değilse, durmalıyız.
• İfadeyi Güncelle: Bu ifade, döngü gövdesi yürütüldükten sonra döngü değişkenini belirli bir değer kadar artırır veya azaltır.

Bir 'For' döngüsünü doğrulamak için C++ program örnekleri:

Örnek:

Bu örnek, 0 ile 10 arasındaki tamsayı değerlerinin yazdırılmasını gösterir.

Bu senaryoda, 0'dan 10'a kadar tamsayıları yazdırmamız gerekiyor. İlk olarak, '0' değeri verilen bir rasgele değişken i'yi başlattık ve daha sonra zaten kullandığımız koşul parametresi, i<=10 ise durumu kontrol eder. Ve koşulu sağladığında ve doğru olduğunda, 'for' döngüsünün yürütülmesi başlar. Yürütmeden sonra, iki artırma veya eksiltme parametresinden biri yürütülecek ve belirtilen koşul i<=10 yanlış olana kadar, i değişkeninin değeri artırılacaktır.

i<10 koşuluyla yineleme sayısı:

Örnek:

Aşağıdaki örnek tamsayının değerini görüntüler:

Yukarıdaki durumda, 'a' adlı bir değişken 50 verilen bir değerle başlatılır. 'a' değişkeninin 70'ten küçük olduğu bir koşul uygulanır. 2. Daha sonra 'a' değeri 50 olan bir başlangıç ​​değerinden başlatılır ve koşul yanlış olana ve 'a' değeri 70'ten artırılana ve döngü sona erene kadar döngü boyunca 2 eşzamanlı olarak eklenir.

Yineleme Sayısı:

Döngü sırasında:

Tanımlanan koşul sağlanana kadar, bir veya daha fazla ifade yürütülebilir. Yineleme önceden bilinmediğinde, çok faydalıdır. İlk olarak, koşul kontrol edilir ve ardından ifadeyi yürütmek veya uygulamak için döngünün gövdesine girer.

İlk satırda, başlık dosyasını ve standart ad alanını birleştiriyoruz. diyoruz ana() işlev. Burada 'a' değişkenini başlatıyoruz. Sonraki satırda ise while koşulunu uyguluyoruz. while koşulu içinde, yazılan değeri görüntülemek için 'cout' ifadesini kullanırız. Ardından, sayıyı artırmak için artırma operatörünü kullanırız. Son satırda ise programı sonlandırmak için 'return 0' ifadesini kullanıyoruz.

Do-While Döngüsü:

Tanımlanan koşul sağlandığında, bir dizi ifade gerçekleştirilir. İlk olarak, döngünün gövdesi gerçekleştirilir. Daha sonra koşulun doğru olup olmadığı kontrol edilir. Bu nedenle, ifade bir kez yürütülür. Döngünün gövdesi, koşul değerlendirilmeden önce bir 'Do-while' döngüsünde işlenir. Program, gerekli koşul sağlandığında çalışır. Aksi halde koşul yanlış olduğunda program sonlandırılır.

Burada başlık dosyasını entegre ediyoruz. biz kullanıyoruz ana() programda işlev görür. Ardından, dört tamsayıyı başlatıyoruz ve kullanıcının değeri girebilmesi için 'cin' ifadesini kullanıyoruz. Bir sonraki satırda, iki farklı tamsayı başlatıyoruz. 'Yap' ifadesini uyguluyoruz. İfadenin içinde iki aritmetik fonksiyon kullanıyoruz. İlk olarak çarpma operatörünü kullanıyoruz ve ikinci olarak toplama operatörünü kullanıyoruz. Ardından programdaki 'while' koşulunu 'do' ifadesinin dışında uygularız. Ayrıca, sonucu 'sonuç' tamsayısıyla yazdırmak için 'cout' ifadesini ekleriz. Son satırda programı sonlandırmak için return 0 komutlarını kullanıyoruz.

C++ Devam/Ara:

C++ Devam Bildirimi:

Devam ifadesi, bir döngünün mevcut bir enkarnasyonunu önlemek ve kontrolü sonraki yinelemeye taşımak için C++ programlama dilinde kullanılır. Döngü sırasında, belirli ifadeleri atlamak için devam ifadesi kullanılabilir. Ayrıca, yönetici ifadeleriyle birlikte döngü içinde de kullanılır. Belirli koşul doğruysa, devam deyimini izleyen tüm ifadeler uygulanmaz.

for döngüsü ile:

Bu örnekte, belirli gereksinimleri geçerken gerekli sonucu elde etmek için C++'dan devam deyimiyle 'for döngüsü' kullanırız.

kitaplığını dahil ederek ve 'namespace std' kullanarak başlıyoruz. O zaman biz diyoruz ana() işlev. For döngüsü kullanıyoruz. For döngüsünün içinde, 3 ile 8 arasında olduğu kabul edilen bir 'k' değişkeni bildiririz. (k = = 5) olsa bile yinelemeye devam etmek için bir koşul kullanırız. Ardından koşulu belirttikten sonra 'devam' ifadesini kullandı. Sonunda. çıktıyı göstermek için 'return 0' komutuyla birlikte 'cout' komutunu kullanırız.

Bir süre döngüsü ile:

Bu gösterim boyunca, ne tür çıktıların üretilebileceğini görmek için bazı koşullar dahil olmak üzere hem 'while döngüsü' hem de C++ 'devam' ifadesini kullandık.

Bu örnekte, yalnızca 40'a sayı eklemek için bir koşul belirledik. Girilen tam sayı negatif bir sayı ise, 'while' döngüsü sonlandırılacaktır. Öte yandan, sayı 40'tan büyükse, o belirli sayı yinelemeden atlanır.

'namespace std' kullanarak kitaplığını ekleyeceğiz ve ardından ana() işlev. Bir 's' değişkeni başlatıyoruz. Bir sonraki adımda başka bir değişken 'sayı' bildirildi. 'while' döngüsünü kullanıyoruz. Şimdi, gerekli değerin sıfıra eşit veya üzerinde olması koşulunu belirtiyoruz. Tüm pozitif sayıları eklemek için 's += sayı' ifadesini kullanırız. Konsolda 'Herhangi bir sayı girin' mesajını göstermek için 'cout' komutu uygulanacaktır. 'cin' ifadesini kullanarak kullanıcıdan tamsayıyı alıyoruz. Ayrıca 'if' ifadesini kullanıyoruz. Tanımlanan sayı 40'tan büyük olduğunda, mesaj gösterilecektir. Ardından 'devam' komutunu kullandık. Tüm bu adımlardan sonra 'devam' ifadesi çalıştırılacaktır. Tüm sayıların toplamını göstermek için 'cout' ifadesini kullanırız.

C++ break Bildirimi:

Break ifadesi C++'da bir döngüde kullanıldığında, döngü anında sonlandırılır ve program kontrolü döngüden sonraki ifadede yeniden başlar. Bir vakayı bir 'switch' deyimi içinde sonlandırmak da mümkündür.

for döngüsü ile:

Burada, farklı değerler üzerinde yineleme yaparak çıktıyı gözlemlemek için 'break' ifadesiyle 'for' döngüsünü kullanacağız.

İlk olarak, bir başlık dosyası ekliyoruz. Ardından, 'namespace std' kullanıyoruz. main() fonksiyonunu çağırdıktan sonra döngü için kullandık. Burada, 'm' değişkenini başlatırdık. 'm' değerinin 10 ile 20 arasında olması koşulunu uygulayacağız. 'break' koşulu sanki (m == 17) gibi yürütülecektir. Sonucu yazdırmak için 'cout' kullandık. Ardından 'dönüş 0' komutu uygulanacaktır.

Bir süre döngüsü ile:

Break ifadesi ile birlikte 'while' döngüsünü kullanacağız.

kitaplığını içe aktararak başlıyoruz. 'Ad alanı std' dahil edilecektir. main() yönteminde, iki değişken 'nbr' ve 'x' başlatılacaktır. 'while' döngüsünü kullandık ve argüman olarak 'true' ilettik. Kullanıcıdan değer elde etmek için 'cin' komutunu kullanıyoruz. Ardından, 'if' ifadesini kullandık. Bununla birlikte, if (nbr < 0) koşulunu belirtmek için 'break' koşulu uygulanır. Tüm pozitif değerleri eklemek için 'x += nbr' formüllerini kullandık. Bu toplamı görüntülemek için 'cout' ifadesini ekledik.

C++ İşlevleri:

İşlevler, önceden bilinen bir programı, yalnızca çağrıldığında yürütülen birden çok kod parçasına yapılandırmak için kullanılır. C++ programlama dilinde bir fonksiyon, uygun bir isim verilen ve onlar tarafından çağrılan bir grup ifade olarak tanımlanır. Kullanıcı, parametre dediğimiz fonksiyonlara veri aktarabilir. İşlevler, kodun yeniden kullanılma olasılığının en yüksek olduğu durumlarda eylemleri uygulamaktan sorumludur.

Bir fonksiyonun oluşturulması:

C++, aşağıdakiler gibi birçok önceden tanımlanmış işlev sunsa da ana(), kodun yürütülmesini kolaylaştırır. Aynı şekilde fonksiyonlarınızı da ihtiyacınıza göre oluşturabilir ve tanımlayabilirsiniz. Tüm sıradan fonksiyonlarda olduğu gibi, burada da '()' sonrasında parantez ile eklenen bir bildirim için fonksiyonunuz için bir isme ihtiyacınız var.

Sözdizimi:

Void, işlevin dönüş türüdür. İşçi, kendisine verilen addır ve küme parantezleri, yürütme kodunu eklediğimiz işlevin gövdesini içine alır.

Bir işlevi çağırmak:

Kodda bildirilen işlevler yalnızca çağrıldıklarında yürütülür. Bir işlevi çağırmak için, noktalı virgül ';' ile devam eden parantez ile birlikte işlevin adını belirtmeniz gerekir.

Örnek:

Bu durumda kullanıcı tanımlı bir fonksiyon tanımlayalım ve inşa edelim.

Başlangıçta, her programda açıklandığı gibi, programın yürütülmesini desteklemek için bize bir kitaplık ve ad alanı atanır. Kullanıcı tanımlı fonksiyon iş gücü() her zaman yazılmadan önce çağrılır ana() işlev. adlı bir işlev iş gücü() 'Emek saygıyı hak eder!' mesajının görüntülendiği yerde ilan edilir. İçinde ana() tamsayı dönüş tipine sahip işlev, biz diyoruz iş gücü() işlev.

Bu, burada görüntülenen kullanıcı tanımlı işlevde tanımlanan basit mesajdır. ana() işlev.

Geçersiz:

Yukarıda bahsedilen örnekte, kullanıcı tanımlı fonksiyonun dönüş tipinin void olduğunu fark ettik. Bu, işlev tarafından herhangi bir değer döndürülmediğini gösterir. Bu, değerin mevcut olmadığını veya muhtemelen boş olduğunu gösterir. Çünkü bir fonksiyon sadece mesajları yazdırdığında, herhangi bir dönüş değerine ihtiyaç duymaz.

Bu boşluk benzer şekilde fonksiyonun parametre uzayında bu fonksiyonun çağrılırken herhangi bir gerçek değer almadığını açıkça belirtmek için kullanılır. Yukarıdaki durumda, biz de çağırırdık iş gücü() işlev olarak:

Gerçek parametreler:

Fonksiyon için parametreler tanımlanabilir. Bir işlevin parametreleri, işlevin adına ekleyen işlevin bağımsız değişken listesinde tanımlanır. Fonksiyonu her çağırdığımızda, yürütmeyi tamamlamak için parametrelerin gerçek değerlerini iletmemiz gerekir. Bunlar Gerçek parametreler olarak sonuçlandırılır. İşlev tanımlanırken tanımlanan parametreler ise Biçimsel Parametreler olarak bilinir.

Örnek:

Bu örnekte, bir fonksiyon aracılığıyla iki tamsayı değerini değiştirmek veya değiştirmek üzereyiz.

Başlangıçta başlık dosyasını alıyoruz. Kullanıcı tanımlı işlev, bildirilen ve tanımlanan adlandırılmış işlevdir. alt(). Bu fonksiyon, i ve n olan iki tamsayı değerinin ikamesi için kullanılır. Daha sonra, bu iki tamsayının değişimi için aritmetik operatörler kullanılır. İlk 'i' tamsayısının değeri, 'n' değeri yerine kaydedilir ve 'i' değeri yerine n'nin değeri kaydedilir. Ardından, değerleri değiştirdikten sonraki sonuç yazdırılır. hakkında konuşursak ana() fonksiyonunda, kullanıcıdan iki tam sayının değerlerini alıyoruz ve görüntülüyoruz. Son adımda, kullanıcı tanımlı fonksiyon alt() çağrılır ve iki değer değiştirilir.

Bu iki sayının yer değiştirmesi durumunda açıkça görebiliriz ki, alt() parametre listesindeki 'i' ve 'n' değerleri resmi parametrelerdir. Gerçek parametreler, işlemin sonunda geçen parametredir. ana() ikame işlevinin çağrıldığı işlev.

C++ İşaretçileri:

C++'da Pointer'ı öğrenmesi oldukça kolaydır ve kullanımı harikadır. C++ dilinde işaretçiler, işimizi kolaylaştırdıkları ve işaretçiler söz konusu olduğunda tüm işlemler büyük bir verimlilikle çalıştığı için kullanılır. Ayrıca, dinamik bellek ayırma gibi işaretçiler kullanılmadıkça gerçekleştirilemeyecek birkaç görev vardır. İşaretçiler hakkında konuşmak, birinin kavraması gereken ana fikir, işaretçinin yalnızca tam bellek adresini değeri olarak saklayacak bir değişken olduğudur. C++'da işaretçilerin yaygın kullanımı aşağıdaki nedenlerden dolayıdır:

• Bir işlevi diğerine geçirmek için.
• Yığındaki yeni nesneleri tahsis etmek için.
• Bir dizideki öğelerin yinelenmesi için

Genellikle, '&' (ve işareti) operatörü, bellekteki herhangi bir nesnenin adresine erişmek için kullanılır.

İşaretçiler ve türleri:

İşaretçi aşağıdaki birkaç türe sahiptir:

• Boş işaretçiler: Bunlar, C++ kitaplıklarında depolanan sıfır değerine sahip işaretçilerdir.
• Aritmetik işaretçi: ++, –, +, - olmak üzere erişilebilir dört ana aritmetik işleç içerir.
• Bir dizi işaretçi: Bazı işaretçileri saklamak için kullanılan dizilerdir.
• İşaretçiden işaretçiye: İşaretçinin işaretçi üzerinde kullanıldığı yerdir.

Örnek:

Birkaç değişkenin adreslerinin yazdırıldığı sonraki örnek üzerinde düşünün.

Başlık dosyasını ve standart ad alanını ekledikten sonra iki değişkeni başlatıyoruz. Biri i' ile temsil edilen bir tamsayı değeri, diğeri ise 10 karakter boyutunda bir karakter türü dizisi olan 'I'dir. Her iki değişkenin adresleri daha sonra 'cout' komutu kullanılarak görüntülenir.

Aldığımız çıktı aşağıda gösterilmiştir:

Bu sonuç, her iki değişkenin adresini gösterir.

Öte yandan, bir işaretçi, değeri kendisi farklı bir değişkenin adresi olan bir değişken olarak kabul edilir. Bir işaretçi her zaman (*) operatörüyle oluşturulan aynı türe sahip bir veri tipine işaret eder.

Bir işaretçinin beyanı:

İşaretçi şu şekilde bildirilir:

İşaretçinin temel türü 'type' ile gösterilirken işaretçinin adı 'var-name' ile ifade edilir. Ve bir değişkeni işaretçiye yetkilendirmek için yıldız işareti (*) kullanılır.

Değişkenlere işaretçi atama yolları:

Neredeyse her zaman, veri türlerinden bağımsız olarak tüm işaretçiler için başlangıçta aynı olan bellek adresini temsil eden uzun bir onaltılık sayı vardır.

Örnek:

Aşağıdaki örnek, işaretçilerin '&' operatörünü nasıl değiştirdiğini ve değişkenlerin adresini nasıl sakladığını gösterecektir.

Kütüphane ve dizin desteğini entegre edeceğiz. O zaman, biz çağırırdık ana() 55 değeri ile 'n' tipinde bir değişkeni ilk olarak bildirip başlattığımız fonksiyon. Sonraki satırda, 'p1' adında bir işaretçi değişkeni başlatıyoruz. Bundan sonra 'n' değişkeninin adresini 'p1' pointer'ına atarız ve ardından 'n' değişkeninin değerini gösteririz. 'p1' işaretçisinde saklanan 'n' adresi görüntülenir. Daha sonra 'cout' komutu kullanılarak ekrana '*p1' değeri yazdırılır. Çıktı aşağıdaki gibidir:

Burada, 'n' değerinin 55 olduğunu ve 'p1' pointer'ında saklanan 'n' adresinin 0x6ffe14 olarak gösterildiğini görüyoruz. Pointer değişkeninin değeri bulunur ve tamsayı değişkenin değeri ile aynı olan 55'tir. Bu nedenle, bir işaretçi, değişkenin adresini depolar ve ayrıca * işaretçisi, depolanan tamsayı değerine sahiptir ve bu, sonuçta başlangıçta depolanan değişkenin değerini döndürür.

Örnek:

Bir dizgenin adresini saklayan bir işaretçi kullandığımız başka bir örneği ele alalım.

Bu kodda, önce kitaplıkları ve ad alanını ekliyoruz. İçinde ana() işlevinde, içinde 'Mascara' değerine sahip 'makyaj' adlı bir dize bildirmemiz gerekiyor. Makyaj değişkeninin adresini saklamak için bir dize türü işaretçi '*p2' kullanılır. 'Makyaj' değişkeninin değeri daha sonra 'cout' ifadesi kullanılarak ekranda görüntülenir. Bundan sonra, 'makyaj' değişkeninin adresi yazdırılır ve sonunda, 'makyaj' değişkeninin işaretçi ile bellek adresini gösteren 'p2' işaretçi değişkeni görüntülenir.

Yukarıdaki koddan alınan çıktı aşağıdaki gibidir:

İlk satır, görüntülenen 'makyaj' değişkeninin değerine sahiptir. İkinci satır, 'makyaj' değişkeninin adresini gösterir. Son satırda ise işaretçi kullanımı ile ‘makyaj’ değişkeninin hafıza adresi gösterilir.

C++ Bellek Yönetimi:

C++'da etkin bellek yönetimi için, C++'da çalışırken belleğin yönetimi için birçok işlem yardımcı olur. C++ kullandığımızda, en yaygın kullanılan bellek ayırma prosedürü, çalışma zamanı sırasında belleklerin değişkenlere atandığı dinamik bellek ayırmadır; derleyicinin belleği değişkenlere ayırabileceği diğer programlama dilleri gibi değil. C++'da, değişken artık kullanımda olmadığında belleğin serbest bırakılması için dinamik olarak ayrılan değişkenlerin serbest bırakılması gereklidir.

C++'da belleğin dinamik tahsisi ve serbest bırakılması için, ' yeni' ve 'silmek' operasyonlar. Hafızanın boşa harcanmaması için hafızayı yönetmek çok önemlidir. Belleğin tahsisi kolay ve etkili hale gelir. Herhangi bir C++ programında, Bellek iki yönden birinde kullanılır: ya bir yığın olarak ya da bir yığın olarak.

• Yığın : Fonksiyon içinde tanımlanan tüm değişkenler ve fonksiyonla ilişkili diğer tüm detaylar stack'te saklanır.
• Yığın : Her türlü kullanılmayan bellek veya bir programın yürütülmesi sırasında dinamik belleği ayırdığımız veya atadığımız kısım yığın olarak bilinir.

Dizileri kullanırken, bellek ayırma, çalışma zamanı olmadıkça belleği belirleyemediğimiz bir görevdir. Bu nedenle, diziye maksimum belleği atarız, ancak çoğu durumda bellek kullanılmadığından ve bir şekilde boşa harcandığından bu iyi bir uygulama değildir, bu da kişisel bilgisayarınız için iyi bir seçenek veya uygulama değildir. Bu nedenle, çalışma zamanı sırasında yığından bellek ayırmak için kullanılan birkaç operatörümüz var. 'Yeni' ve 'Sil' adlı iki ana operatör, verimli bellek tahsisi ve serbest bırakma için kullanılır.

C++ yeni operatör:

Yeni operatör, belleğin tahsisinden sorumludur ve aşağıdaki şekilde kullanılır:

Bu koda kitaplığını ve ad alanını dahil ediyoruz. Ardından, 'int' veri türü ile bir işaretçi başlattık. Bir sonraki satırda, bu işaretçiye 'yeni' operatör atanır.

Bir işaretçi kullanımıyla bellek başarıyla 'int' değişkenine tahsis edildi.

C++ silme operatörü:

Bir değişkeni kullanmayı bitirdiğimizde, bir zamanlar tahsis ettiğimiz belleği artık kullanımda olmadığı için yeniden tahsis etmeliyiz. Bunun için hafızayı serbest bırakmak için 'sil' operatörünü kullanıyoruz.

Şu anda inceleyeceğimiz örnek, her iki operatörün de dahil edilmesidir.

Kullanıcıdan alınan üç farklı değerin ortalamasını hesaplıyoruz. İşaretçi değişkenleri, değerleri depolamak için 'yeni' operatörüyle atanır. Ortalama formülü uygulanır. Bundan sonra, 'yeni' operatörü kullanılarak işaretçi değişkenlerinde saklanan değerleri silen 'sil' operatörü kullanılır. Bu, tahsisin çalışma zamanı sırasında yapıldığı ve ardından serbest bırakmanın program sona erdikten hemen sonra gerçekleştiği dinamik tahsistir.

Bellek Tahsisi için dizi kullanımı:

Şimdi dizileri kullanırken 'new' ve 'delete' operatörlerinin nasıl kullanıldığını göreceğiz. Sözdizimi hemen hemen aynı olduğundan dinamik ayırma, değişkenler için olduğu gibi gerçekleşir.

Verilen örnekte, değeri kullanıcıdan alınan eleman dizisini düşünüyoruz. Dizinin öğeleri alınır ve işaretçi değişkeni bildirilir ve ardından bellek ayrılır. Bellek tahsisinden hemen sonra dizi elemanlarının giriş prosedürü başlatılır. Ardından, dizi öğelerinin çıktısı bir 'for' döngüsü kullanılarak gösterilir. Bu döngü, n ile temsil edilen dizinin gerçek boyutundan daha küçük bir boyuta sahip öğelerin yineleme koşuluna sahiptir.

Tüm elemanlar kullanıldığında ve tekrar kullanılmaları için başka bir gereklilik olmadığında, elemanlara atanan hafıza 'delete' operatörü kullanılarak serbest bırakılır.

Çıktıda, iki kez yazdırılan değer kümelerini görebiliyorduk. İlk 'for' döngüsü, elemanların değerlerini yazmak için kullanıldı ve diğer 'for' döngüsü, kullanıcının bu değerleri netlik için yazdığını gösteren önceden yazılmış değerleri yazdırmak için kullanıldı.

Avantajlar:

'Yeni' ve 'sil' operatörü, C++ programlama dilinde her zaman önceliktir ve yaygın olarak kullanılır. Kapsamlı bir tartışma ve anlayış olduğunda, 'yeni' operatörün çok fazla avantajı olduğu belirtilmektedir. Bellek tahsisi için 'yeni' operatörün avantajları şunlardır:

• Yeni operatör daha kolay bir şekilde aşırı yüklenebilir.
• Çalışma zamanı sırasında bellek tahsis edilirken, yeterli bellek olmadığında, yalnızca programın sonlandırılması yerine otomatik bir istisna atılır.
• 'Yeni' operatör, tahsis ettiğimiz bellekle aynı türe sahip olduğundan, tip belirleme prosedürünü kullanma telaşı burada mevcut değildir.
• 'Yeni' operatörü ayrıca sizeof() operatörünü kullanma fikrini de reddeder, çünkü 'yeni' kaçınılmaz olarak nesnelerin boyutunu hesaplayacaktır.
• 'Yeni' operatörü, nesneler için kendiliğinden alan oluştursa bile, nesneleri başlatmamızı ve bildirmemizi sağlar.

C++ Dizileri:

Dizilerin ne olduğu ve bir C++ programında nasıl bildirildiği ve uygulandığı hakkında kapsamlı bir tartışma yapacağız. Dizi, birden çok değeri tek bir değişkende depolamak için kullanılan bir veri yapısıdır, böylece birçok değişkeni bağımsız olarak bildirme telaşını azaltır.

Dizilerin beyanı:

Bir diziyi bildirmek için, önce değişkenin türünü tanımlamalı ve daha sonra köşeli parantezler boyunca eklenen diziye uygun bir isim vermelidir. Bu, belirli bir dizinin boyutunu gösteren öğelerin sayısını içerecektir.

Örneğin:

Bu değişken, 'makyaj' adlı bir dizide beş dize içerdiğini göstererek bildirildi. Bu dizinin değerlerini tanımlamak ve göstermek için, her bir elemanı ayrı ayrı çift ters virgül içine alınmış ve her biri aralarında tek bir virgülle ayrılmış olarak küme parantezlerini kullanmamız gerekir.

Örneğin:

Benzer şekilde, 'int' olması gereken farklı bir veri türüyle başka bir dizi oluşturmak istiyorsanız, prosedür aynı olacaktır, aşağıda gösterildiği gibi değişkenin veri türünü değiştirmeniz yeterlidir:

Diziye tamsayı değerleri atanırken, yalnızca dize değişkeni için işe yarayacak olan ters virgüllerde bulunmamalıdır. Sonuç olarak bir dizi, içlerinde saklanan türetilmiş veri türleri ile birbiriyle ilişkili veri öğelerinin bir koleksiyonudur.

Dizideki öğelere nasıl erişilir?

Dizideki tüm öğelere, diziden bir öğeye erişmek için kullanılan dizin numaraları olan farklı bir sayı atanır. Dizin değeri, dizinin boyutundan bir küçük olana kadar 0 ile başlar. İlk değerin indeks değeri 0'dır.

Örnek:

Bir dizideki değişkenleri başlatacağımız çok basit ve kolay bir örnek düşünün.

İlk adımda, programda gerekli tüm kitaplıkları otomatik olarak ekleyecek olan başlık dosyasını dahil ediyoruz. 'std' ad alanı, dizinler için kapsam sağlayacaktır. Üçüncü satırda, biz diyoruz ana() işlev. Kıvrımlı ayraç, işlevin başladığını belirtir. Fonksiyona girdikten sonra 'digits' adında 'int' tipi bir dizi bildireceğiz. 4 boyutunu içerir, yani aynı anda yalnızca 4 tamsayı değeri içerebilir. Dizideki öğelerin her birine ayrı ayrı benzersiz ve farklı bir rakam atanmıştır. Ardından tüm dizi, her bir öğe ayrı ayrı çağrılacak şekilde görüntülenir.

Bu, yukarıdaki koddan alınan sonuçtur. 'endl' anahtar sözcüğü, diğer öğeyi otomatik olarak bir sonraki satıra taşır.

Örnek:

Bu kodda, bir dizinin öğelerini yazdırmak için bir 'for' döngüsü kullanıyoruz.

Yukarıdaki örnekte, temel kitaplığı ekliyoruz. Standart ad alanı ekleniyor. bu ana() işlev, belirli bir programın yürütülmesi için tüm işlevleri gerçekleştireceğimiz işlevdir. Daha sonra 'Num' adında 10 büyüklüğünde bir int tipi dizi tanımlıyoruz. Bu on değişkenin değeri kullanıcıdan 'for' döngüsü kullanılarak alınır. Bu dizinin gösterimi için tekrar bir 'for' döngüsü kullanılır. Dizide saklanan 10 tam sayı, 'cout' ifadesi yardımıyla görüntülenir.

Bu, yukarıdaki kodun yürütülmesinden elde ettiğimiz çıktıdır ve farklı değerlere sahip 10 tam sayıyı gösterir.

Örnek:

Bu senaryoda, bir öğrencinin ortalama puanını ve sınıfta aldığı yüzdeyi bulmak üzereyiz.

İlk olarak, C++ programına ilk desteği sağlayacak bir kitaplık eklemeniz gerekiyor. Ardından, 'Score' adlı dizinin 5 boyutunu belirtiyoruz. Ardından, veri türü float'ının bir 'toplamı' değişkenini başlattık. Her konunun puanları kullanıcıdan manuel olarak alınır. Ardından, dahil edilen tüm konuların ortalamasını ve yüzdesini bulmak için bir 'for' döngüsü kullanılır. Toplam, dizi ve 'for' döngüsü kullanılarak elde edilir. Daha sonra ortalama formülü kullanılarak ortalama bulunur. Ortalamayı bulduktan sonra yüzdeyi almak için formüle eklenen yüzdeye değerini geçiyoruz. Ortalama ve yüzde daha sonra hesaplanır ve görüntülenir.

Bu, her bir konu için kullanıcıdan puanların ayrı ayrı alındığı ve sırasıyla ortalama ve yüzdenin hesaplandığı son çıktıdır.

Dizileri kullanmanın avantajları:

• Dizideki öğelere, kendilerine atanan dizin numarası nedeniyle erişmek kolaydır.
• Bir dizi üzerinden arama işlemini kolaylıkla yapabiliriz.
• Programlamada karmaşıklık istiyorsanız, matrisleri de karakterize eden 2 boyutlu bir dizi kullanabilirsiniz.
• Benzer bir veri tipine sahip birden çok değeri saklamak için bir dizi kolaylıkla kullanılabilir.

Dizileri kullanmanın dezavantajları:

• Dizilerin sabit bir boyutu vardır.
• Diziler homojendir; bu, yalnızca tek bir değer türünün depolandığı anlamına gelir.
• Diziler, verileri fiziksel bellekte ayrı ayrı depolar.
• Diziler için ekleme ve silme işlemi kolay değildir.

C++ Nesneleri ve Sınıfları:

C++, nesne yönelimli bir programlama dilidir; bu, nesnelerin C++'ta hayati bir rol oynadığı anlamına gelir. Nesneler hakkında konuşurken önce nesnelerin ne olduğu düşünülmelidir, bu nedenle bir nesne sınıfın herhangi bir örneğidir. C++ OOP kavramlarıyla ilgilenirken, tartışılması gereken başlıca şeyler nesneler ve sınıflardır. Sınıflar aslında kullanıcının kendisi tarafından tanımlanan ve veri üyelerini kapsüllemek için atanan veri türleridir ve yalnızca belirli bir sınıf için örneğine erişilebilen işlevler oluşturulur. Veri üyeleri, sınıf içinde tanımlanan değişkenlerdir.

Diğer bir deyişle sınıf, veri üyelerinin tanımlanmasından ve bildirilmesinden ve bu veri üyelerine atanan işlevlerden sorumlu olan bir taslak veya tasarımdır. Sınıfta bildirilen nesnelerin her biri, sınıf tarafından gösterilen tüm özellikleri veya işlevleri paylaşabilecektir.

Kuşlar adında bir sınıf olduğunu varsayalım, şimdi başlangıçta tüm kuşlar uçabilir ve kanatları olabilir. Dolayısıyla uçmak, bu kuşların benimsediği bir davranıştır ve kanatlar vücutlarının bir parçası veya temel bir özelliğidir.

Bir sınıf tanımlama:

Bir sınıf tanımlamak için sözdizimini takip etmeniz ve sınıfınıza göre sıfırlamanız gerekir. Sınıfı tanımlamak için 'sınıf' anahtar sözcüğü kullanılır ve diğer tüm veri üyeleri ve işlevler küme parantezleri içinde tanımlanır ve ardından sınıfın tanımı gelir.

Nesneleri bildirmek:

Bir sınıf tanımladıktan hemen sonra, sınıf tarafından belirtilen işlevlere erişmek ve bunları tanımlamak için nesneler oluşturmamız gerekir. Bunun için sınıfın adını ve ardından bildirim için nesnenin adını yazmalıyız.

Veri üyelerine erişim:

Fonksiyonlara ve veri üyelerine basit bir nokta '.' Operatörü yardımıyla erişilir. Bu operatör ile kamuya açık veri üyelerine de erişilir ancak özel veri üyeleri söz konusu olduğunda, onlara doğrudan erişemezsiniz. Veri üyelerinin erişimi, özel, genel veya korumalı erişim değiştiricileri tarafından kendilerine verilen erişim kontrollerine bağlıdır. İşte basit sınıfın, veri üyelerinin ve işlevlerin nasıl bildirileceğini gösteren bir senaryo.

Örnek:

Bu örnekte, birkaç fonksiyon tanımlayacağız ve nesneler yardımıyla sınıf fonksiyonlarına ve veri üyelerine erişeceğiz.

İlk adımda, kütüphaneyi entegre ediyoruz, ardından destekleyici dizinleri eklememiz gerekiyor. Sınıf, çağrılmadan önce açıkça tanımlanır. ana() işlev. Bu sınıfa 'araç' denir. Veri üyeleri, sırasıyla aracın 'adı ve o aracın plaka numarası olan 'id' ve int veri tipi idi. Bu iki veri üyesi için iki işlev bildirildi. bu İD() işlev, aracın kimliğini görüntüler. Sınıfın veri üyeleri herkese açık olduğundan, onlara sınıfın dışında da erişebiliriz. Bu nedenle, biz diyoruz isim() sınıfın dışında işlev görür ve ardından kullanıcıdan 'VehicleName' değerini alır ve bir sonraki adımda yazdırır. İçinde ana() function, sınıftan veri üyelerine ve fonksiyonlara erişmeye yardımcı olacak gerekli sınıfın bir nesnesini ilan ediyoruz. Ayrıca, yalnızca kullanıcı aracın adı için değer vermezse, aracın adı ve kimliği için değerleri başlatıyoruz.

Bu, kullanıcının araca kendi adını verdiğinde alınan çıktıdır ve plakalar, kendisine atanan statik değerdir.

Üye fonksiyonların tanımından bahsederken, fonksiyonu sınıf içinde tanımlamanın her zaman zorunlu olmadığı anlaşılmalıdır. Yukarıdaki örnekte görebileceğiniz gibi, veri üyeleri public olarak bildirildiği için sınıfın işlevini sınıf dışında tanımlıyoruz ve bu, '::' olarak gösterilen kapsam çözümleme operatörü ve adı ile birlikte yapılır. sınıf ve işlevin adı.

C++ Yapıcılar ve Yıkıcılar:

Örnekler yardımıyla bu konuyu kapsamlı bir şekilde inceleyeceğiz. C++ programlamasında nesnelerin silinmesi ve oluşturulması çok önemlidir. Bunun için, bir sınıf için bir örnek oluşturduğumuzda, birkaç durumda otomatik olarak yapıcı yöntemlerini çağırırız.

Yapıcılar:

Adından da anlaşılacağı gibi, bir kurucu, bir şeyin yaratılmasını belirten 'construct' kelimesinden türetilmiştir. Bu nedenle, yapıcı, yeni oluşturulan sınıfın, sınıfın adını paylaşan türetilmiş bir işlevi olarak tanımlanır. Ve sınıfa dahil olan nesnelerin başlatılması için kullanılır. Ayrıca, bir kurucunun kendisi için bir dönüş değeri yoktur, bu da dönüş türünün de geçersiz olmayacağı anlamına gelir. Argümanları kabul etmek zorunlu değildir, ancak gerekirse eklenebilir. Yapıcılar, bir sınıfın nesnesine bellek tahsisinde ve üye değişkenler için başlangıç ​​değerinin ayarlanmasında faydalıdır. Başlangıç ​​değeri, nesne başlatıldığında yapıcı işlevine argümanlar biçiminde iletilebilir.

Sözdizimi:

Yapıcı Türleri:

Parametreli yapıcı:

Daha önce tartışıldığı gibi, bir kurucunun herhangi bir parametresi yoktur, ancak kişi istediği bir parametreyi ekleyebilir. Bu, oluşturulurken nesnenin değerini başlatacaktır. Bu kavramı daha iyi anlamak için aşağıdaki örneği inceleyin:

Örnek:

Bu örnekte, sınıfın bir yapıcısını yaratacak ve parametreleri bildireceğiz.

Başlık dosyasını ilk adımda ekliyoruz. Bir ad alanı kullanmanın bir sonraki adımı, programın dizinlerini desteklemektir. 'Rakamlar' adlı bir sınıf, ilk olarak, değişkenlerin program boyunca erişilebilir olmaları için genel olarak başlatıldığı yerde bildirilir. Veri türü tamsayılı 'dig1' adlı bir değişken bildirildi. Ardından, adı sınıfın adına benzer bir kurucu tanımladık. Bu yapıcı kendisine 'n' olarak iletilen bir tamsayı değişkenine sahiptir ve 'dig1' sınıf değişkeni n'ye eşit olarak ayarlanır. İçinde ana() Programın işlevi, 'digits' sınıfı için üç nesne oluşturulur ve bazı rastgele değerler atanır. Bu nesneler daha sonra aynı değerlerle atanan sınıf değişkenlerini otomatik olarak çağırmak için kullanılır.

Tamsayı değerleri ekranda çıktı olarak sunulur.

Yapıcıyı kopyala:

Nesneleri argüman olarak kabul eden ve bir nesnenin veri üyelerinin değerlerini diğerine kopyalayan yapıcı türüdür. Bu nedenle, bu yapıcılar bir nesneyi diğerinden bildirmek ve başlatmak için kullanılır. Bu işleme kopya başlatma denir.

Örnek:

Bu durumda, kopya oluşturucu bildirilecektir.

İlk olarak, kütüphane ve dizini entegre ediyoruz. Tamsayıların 'e' ve 'o' olarak başlatıldığı 'New' adlı bir sınıf bildirilir. Yapıcı, iki değişkene değerlerin atandığı ve bu değişkenlerin sınıfta bildirildiği yerde halka açık hale getirilir. Daha sonra, bu değerler yardımı ile görüntülenir. ana() dönüş türü olarak 'int' ile işlev. bu Görüntüle() Numaraların ekranda görüntülendiği fonksiyon daha sonra çağrılır ve tanımlanır. İçinde ana() işlev, nesneler yapılır ve bu atanan nesneler rastgele değerlerle başlatılır ve ardından Görüntüle() yöntem kullanılmaktadır.

Kopya oluşturucunun kullanımıyla alınan çıktı aşağıda gösterilmiştir.

Yok Ediciler:

Adından da anlaşılacağı gibi yıkıcılar, yapıcı tarafından oluşturulan nesneleri yok etmek için kullanılır. Yapıcılarla karşılaştırıldığında, yıkıcılar sınıfla aynı ada sahiptir, ancak ardından ek bir yaklaşık işareti (~) gelir.

Sözdizimi:

Yıkıcı herhangi bir argüman almaz ve hatta herhangi bir dönüş değerine sahip değildir. Derleyici, artık erişilemeyen depolamayı temizlemek için programdan dolaylı olarak çıkışa başvurur.

Örnek:

Bu senaryoda, bir nesneyi silmek için bir yıkıcı kullanıyoruz.

Burada bir 'Ayakkabı' sınıfı yapılır. Sınıfınkine benzer bir ada sahip bir yapıcı oluşturulur. Yapıcıda, nesnenin oluşturulduğu yerde bir mesaj görüntülenir. Yapıcıdan sonra, yapıcı ile oluşturulan nesneleri silen yıkıcı yapılır. İçinde ana() işlevinde, 's' adında bir işaretçi nesnesi oluşturulur ve bu nesneyi silmek için 'delete' anahtar sözcüğü kullanılır.

Yıkıcının oluşturulan nesneyi temizleyip yok ettiği programdan aldığımız çıktı bu.

Yapıcılar ve Yıkıcılar Arasındaki Fark:

C++ Kalıtımı:

Şimdi C++ Kalıtımı ve Kapsamını öğreneceğiz.

Kalıtım, yeni bir sınıfın oluşturulduğu veya mevcut bir sınıftan türetildiği yöntemdir. Mevcut sınıfa “temel sınıf” veya “üst sınıf” ve oluşturulan yeni sınıfa “türetilmiş sınıf” adı verilir. Bir alt sınıfın bir üst sınıftan miras alındığını söylediğimizde, çocuğun ebeveyn sınıfın tüm özelliklerine sahip olduğu anlamına gelir.

Kalıtım (is a) ilişkisini ifade eder. İki sınıf arasında 'is-a' kullanılıyorsa, herhangi bir ilişkiye kalıtım diyoruz.

Örneğin:

• Papağan bir kuştur.
• Bilgisayar bir makinedir.

Sözdizimi:

C++ programlamasında Kalıtımı aşağıdaki gibi kullanır veya yazarız:

C++ Kalıtım Modları:

Kalıtım, sınıfları miras almak için 3 Mod içerir:

• Halk: Bu modda, bir alt sınıf bildirilirse, bir üst sınıfın üyeleri, bir üst sınıfta olduğu gibi alt sınıf tarafından miras alınır.
• Korumalı: ben Bu modda, ana sınıfın genel üyeleri, alt sınıfta korunan üyeler haline gelir.
• Özel : Bu modda, bir üst sınıfın tüm üyeleri alt sınıfta özel hale gelir.

C++ Kalıtım Türleri:

C++ kalıtım türleri şunlardır:

1. Tek Miras:

Bu tür kalıtımla, sınıflar bir temel sınıftan kaynaklanır.

Sözdizimi:

2. Çoklu Kalıtım:

Bu tür kalıtımda, bir sınıf farklı temel sınıflardan gelebilir.

Sözdizimi:

3. Çok Düzeyli Kalıtım:

Bir alt sınıf, bu kalıtım biçiminde başka bir alt sınıftan türemiştir.

Sözdizimi:

4. Hiyerarşik Miras:

Bu kalıtım yönteminde bir temel sınıftan birkaç alt sınıf oluşturulur.

Sözdizimi:

5. Hibrit Kalıtım:

Bu tür kalıtımda, çoklu kalıtım birleştirilir.

Sözdizimi:

Örnek:

C++ programlamasında Çoklu Kalıtım kavramını göstermek için kodu çalıştıracağız.

Standart bir girdi-çıktı kitaplığı ile başladığımız için, temel sınıfa 'Bird' adını verdik ve üyelerinin erişilebilir olması için onu herkese açık hale getirdik. Ardından, 'Sürüngen' temel sınıfımız var ve onu da herkese açık hale getirdik. Ardından, çıktıyı yazdırmak için 'cout'umuz var. Bundan sonra alt sınıf bir 'penguen' yarattık. İçinde ana() fonksiyon penguen 'p1' sınıfının nesnesini yaptık. Önce 'Kuş' sınıfı ve ardından 'Sürüngen' sınıfı yürütülecektir.

C++'da kod çalıştırıldıktan sonra, 'Bird' ve 'Reptile' temel sınıflarının çıktı ifadelerini alırız. Bu, bir penguen bir kuş olduğu kadar bir sürüngen olduğu için bir 'penguen' sınıfının 'Kuş' ve 'Sürüngen' temel sınıflarından türetildiği anlamına gelir. Hem uçabilir hem de sürünebilir. Dolayısıyla çoklu kalıtım, bir alt sınıfın birçok temel sınıftan türetilebileceğini kanıtladı.

Örnek:

Burada Çok Düzeyli Kalıtımın nasıl kullanılacağını gösteren bir program yürüteceğiz.

Giriş-Çıkış Akışlarını kullanarak programımıza başladık. Ardından, genel olarak ayarlanmış bir ebeveyn sınıfı 'M' ilan ettik. biz aradık Görüntüle() ifadeyi görüntülemek için function ve 'cout' komutu. Daha sonra, 'M' üst sınıfından türetilen bir alt sınıf 'N' yarattık. 'N' alt sınıfından türetilmiş yeni bir 'O' alt sınıfımız var ve türetilmiş her iki sınıfın gövdesi boş. Sonunda, çağırıyoruz ana() 'O' sınıfının nesnesini başlatmamız gereken işlev. bu Görüntüle() sonucu göstermek için nesnenin işlevi kullanılır.

Bu şekilde, ana sınıf olan 'M' sınıfının sonucuna sahibiz çünkü bir Görüntüle() içinde işlev görür. Dolayısıyla, 'N' sınıfı, 'M' üst sınıfından ve çok düzeyli kalıtımı ifade eden 'N' üst sınıfından 'O' Sınıfından türetilir.

C++ Polimorfizmi:

'Polimorfizm' terimi, iki kelimeden oluşan bir koleksiyonu temsil eder. 'poli' ve ' biçimcilik' . 'Poli' kelimesi 'çok'u, 'morfizm' ise 'biçimleri' temsil eder. Polimorfizm, bir nesnenin farklı koşullarda farklı davranabileceği anlamına gelir. Bir programcının kodu yeniden kullanmasına ve genişletmesine izin verir. Aynı kod, duruma göre farklı davranır. Bir nesnenin canlandırılması çalışma zamanında kullanılabilir.

Polimorfizm Kategorileri:

Polimorfizm esas olarak iki yöntemle oluşur:

1. Derleme Zamanı Polimorfizmi
2. Çalışma Zamanı Polimorfizmi

açıklayalım.

6. Derleme Zamanı Polimorfizmi:

Bu süre içinde girilen program çalıştırılabilir bir programa dönüştürülür. Kodun dağıtımından önce hatalar tespit edilir. Bunun başlıca iki kategorisi vardır.

• İşlev Aşırı Yüklemesi
• Operatör Aşırı Yüklemesi

Şimdi bu iki kategoriyi nasıl kullandığımıza bakalım.

7. İşlev Aşırı Yüklemesi:

Bu, bir işlevin farklı görevleri yerine getirebileceği anlamına gelir. Benzer ada sahip ancak farklı argümanlara sahip birkaç işlev olduğunda, işlevler aşırı yüklenmiş olarak bilinir.

İlk olarak, standart ad alanının yanı sıra kitaplığını da kullanırız. Sonra kullanıcı tanımlı sınıfı 'Ekle' ilan edeceğiz. Sınıf içinde, public olarak iki parametreli bir ADD() fonksiyonu tanımlıyoruz. Yine, sınıfın gövdesi içinde aynı ada sahip yeni bir fonksiyon tanımlayın ancak bu fonksiyonun parametresi yok. Burada üç dizeyi başlatıyoruz. İlk iki dizenin bir değeri vardır ve son dize, ilk iki dizeyi birleştirmek için kullanılır. Sonucu yazdırmak için 'cout' komutunu kullanıyoruz. Sonraki, biz diyoruz ana() sınıfın dışında bir yöntem. Gerekli 'Add' sınıfının bir nesnesini oluşturuyoruz. Şimdi ilk fonksiyonu iki parametre ile çağırıyoruz ve ardından ikinci fonksiyonu da çağırıyoruz. Son adımda ise programı sonlandırmak için 'return 0' ifadesini ekliyoruz.

Operatör Aşırı Yüklemesi:

Bir operatörün çoklu işlevlerini tanımlama sürecine operatör aşırı yüklemesi denir.

Yukarıdaki örnek, başlık dosyasını içerir. Ardından, standart bir ad alanı kullanıyoruz. 'Integer' sınıfını tanımlıyoruz. Bu sınıf içinde, bir sınıfın özel üyesi olarak bir tamsayı belirtiriz. Ardından, Parameterized yapıcıyı genel üye olarak ilan ediyoruz ve içindeki tamsayı değerini başlatıyoruz. Aşırı yükleme önek operatörü ile bir kurucu tanımlarız. Bu yapıcının içinde önek işlemi gerçekleştiriyoruz. Ayrıca, 'cout' ifadesini kullanarak artış değerini gösteren bir fonksiyon oluşturuyoruz. Bu arada, biz çağırıyoruz ana() işlev. Burada iki sınıf nesnesi oluşturuyoruz. İlk nesne tam sayının bir değerini iletir. Ardından, 'Değeri artırmadan önce' satırını yazdırmak için 'cout' ifadesini kullanın. Sonra, diyoruz Görüntüle() İlk nesne için işlev. İkinci nesne, artış öncesi operatörünü kullanır. “Ön artımdan sonra değerdir” satırını göstermek için 'cout' komutunu kullanıyoruz. Daha sonra, Görüntüle() ikinci nesne için işlev.

8. Çalışma Zamanı Polimorfizmi:

Kodun çalıştığı zaman aralığıdır. Kodun kullanılmasından sonra hatalar tespit edilebilir.

İşlev Geçersiz Kılma:

Türetilmiş bir sınıf, temel sınıf üye işlevlerinden biriyle benzer bir işlev tanımı kullandığında gerçekleşir.

İlk satırda, giriş ve çıkış işlemlerini yürütmek için kitaplığını dahil ediyoruz. Ayrıca, standart ad alanını ekliyoruz. Bir sonraki satırda, bir ebeveyn sınıfı 'Man' ilan ediyoruz. Sınıf içinde public olarak iki parametreli bir fonksiyon tanımlıyoruz. Ardından, “Walking” metnini görüntülemek için “cout” ifadesini kullanırız. Sınıfın dışında, ana sınıftan türetilmiş bir alt sınıf 'Animal' oluşturuyoruz. Burada, daha önce üst sınıfta bildirilenle benzer bir ada sahip bir işlev oluşturuyoruz. Ardından, 'Yeme' metnini göstermek için 'cout' ifadesini kullanın. kullanıyoruz ana() işlev. Bu arada, bir sınıf nesnesi 'm' oluşturuyoruz. Daha sonra, üst sınıfın işlevinin yanı sıra alt sınıfın işlevini de çağırırız. '0 döndür' komutunu kullanın.

C++ Dizeleri:

Şimdi, String'in C++'da nasıl bildirileceğini ve başlatılacağını keşfedeceğiz. String, programda bir grup karakter saklamak için kullanılır. Programda alfabetik değerleri, rakamları ve özel tip sembolleri saklar. C++ programında karakterleri bir dizi olarak ayırdı. Diziler, C++ programlamasında bir koleksiyon veya karakter kombinasyonunu ayırmak için kullanılır. Diziyi sonlandırmak için boş karakter olarak bilinen özel bir sembol kullanılır. Kaçış dizisi (\0) ile temsil edilir ve dizenin sonunu belirtmek için kullanılır.

'cin' komutunu kullanarak dizeyi alın:

İçinde boşluk olmayan bir dize değişkeni girmek için kullanılır. Verilen örnekte, 'cin' komutunu kullanarak kullanıcının adını alan bir C++ programı uyguluyoruz.

İlk adımda kütüphanesini kullanıyoruz. Bu arada, standart ad alanını dahil ettik. Ardından, beyan ederiz ana() işlev. Gövde içinde bir karakter tipi dizesi başlatıyoruz. ana() işlev. Ardından “cout” deyimini kullanarak “Adınızı girin” yazıyoruz. Kullanıcıdan dizeyi istemek için 'cin' komutunu kullanıyoruz. Kullanıcı tarafından yazılacak ismi yazdırmak için 'cout' komutu uygulanır. Programı sonlandırmak için return 0 ifadesi eklenir.

Kullanıcı “Ahmed Chaudry” adını girer. Ancak çıktı olarak tam 'Ahmed Chaudry' yerine yalnızca 'Ahmed' alıyoruz çünkü 'cin' komutu boşluklu bir dize depolayamıyor. Yalnızca boşluktan önceki değeri depolar.

cin.get() işlevini kullanarak dizeyi alın:

bu almak() cin komutunun işlevi, boşluk içerebilecek dizeyi klavyeden almak için kullanılır.

Yukarıdaki örnek, giriş ve çıkış işlemlerini gerçekleştirmek için kitaplığını içerir. Daha sonra standart bir ad alanı kullandık. bu ana() fonksiyon denir. Bundan sonra, 's' adlı bir dize başlatıyoruz. Bir sonraki adımda, “Enter a String” ifadesini görüntülemek için 'cout' komutu kullanılır. bu cin.get() dizeyi kullanıcıdan almak için uygulanır. kullanarak cin.get() fonksiyona bir string değeri iletiriz ve stringin boyutunu parametre olarak belirtiriz. Programın çıktısını görüntülemek için tekrar 'cout' komutu kullanılır. Sonunda, 0 dönüşünü ekliyoruz.

Kullanıcı tarafından “Benim adım Ali” dizesi girilir. cin.get() işlevi boşluk içeren dizeleri kabul ettiğinden, sonuç olarak 'Benim adım Ali' tam dizesini alıyoruz.

2B (İki Boyutlu) Dize Dizisini Kullanma:

Bu durumda, 2B dizi dizisini kullanarak kullanıcıdan girdi (üç şehrin adı) alırız.

İlk olarak, başlık dosyasını ve standart bir ad alanını entegre ediyoruz. biz çağırırız ana() işlev. Ardından, üç satır ve on beş sütunlu iki boyutlu bir karakter dizisini başlatıyoruz. Bir sonraki adımda, boş karakter tanımlanana kadar gerekli dize üzerinde yinelemek için 'i' değişkenini saymak için for döngüsü kullanılır. 'For' döngüsünün gövdesi içinde, 'Enter city name' satırını göstermek için 'cout' komutunu kullanıyoruz. Ardından şehir adını almak için 'cin' ifadesini kullanın. Döngü sona erene kadar şehirlerin adlarını sırayla görüntülemek için yine başka bir 'for' döngüsü ve 'cout' ifadesi kullanıyoruz. Ardından, 'dönüş 0' komutu kullanılır.

Burada kullanıcı üç farklı şehrin adını girer. Program, üç dize değeri elde etmek için bir satır dizini kullanır. Her değer kendi satırında tutulur. İlk dize ilk satırda saklanır vb. Her dize değeri, satır dizini kullanılarak aynı şekilde görüntülenir.

C++ Standart Kitaplığı:

C++ kitaplığı, hemen hemen tek bir uygun kümede yer alan, her zaman standartlaştırılmış başlık dosyalarını tanımlayan ve bildiren birçok işlevin, sınıfın, sabitin ve ilgili tüm öğelerin bir kümesi veya grubudur. Bunların uygulanması, ve adlı C++ standardının gerektirmediği iki yeni başlık dosyasını içerir. Derleyicinin gereksinimine bağlı olarak, zorunlu başlık dosyalarının uzun bir listesi mevcuttur. Başlık dosyaları, Stand Kitaplığı Şablonu (STL) için özel başlık dosyaları dahil olmak üzere, C++ Standart Kitaplığındaki tüm içeriği içeren başlık listesini içerir.

Standart Kitaplık, programlama sırasında talimatları yeniden yazma zahmetini ortadan kaldırır. Bu, içinde birçok işlev için kod depolayan birçok kitaplığa sahiptir. Bu kütüphanelerden en iyi şekilde yararlanmak için onları başlık dosyaları yardımıyla birbirine bağlamak zorunludur. Girdi veya çıktı kitaplığını içe aktardığımızda, bu, o kitaplığın içinde depolanmış olan tüm kodu içe aktardığımız anlamına gelir ve bu, ihtiyacınız olmayabilecek tüm temel kodları gizleyerek, içindeki işlevleri de bu şekilde kullanabiliriz. görmek.

C++ standart kitaplığı aşağıdaki iki türü destekler:

• C++ ISO standardı tarafından açıklanan tüm temel standart kitaplık başlık dosyalarını sağlayan barındırılan bir uygulama.
• Standart kitaplıktan yalnızca başlık dosyalarının bir bölümünü gerektiren bağımsız bir uygulama. Uygun alt küme:

Son 11 C++'ın gelmesinden bu yana birkaç başlık dosyası reddedildi: Bunlar , ve .

Barındırılan ve bağımsız uygulamalar arasındaki farklar aşağıda gösterildiği gibidir:

• Barındırılan uygulamada, ana işlev olan global bir işlev kullanmamız gerekiyor. Bağımsız bir uygulamadayken, kullanıcı başlangıç ​​ve bitiş işlevlerini kendi başına bildirebilir ve tanımlayabilir.
• Bir barındırma uygulaması, eşleşen zamanda zorunlu olarak çalışan bir iş parçacığına sahiptir. Oysa bağımsız uygulamada, uygulayıcılar eşzamanlı iş parçacığının desteğine kitaplıklarında ihtiyaç duyup duymadıklarına kendileri karar vereceklerdir.

Türler:

Hem bağımsız hem de barındırılan C++ tarafından desteklenir. Başlık dosyaları aşağıdaki ikiye ayrılır:

• Iostream parçaları
• C++ STL parçaları (Standart Kitaplık)

Ne zaman C++'da yürütülecek bir program yazsak, her zaman STL içinde gerçekleştirilmiş olan işlevleri çağırırız. Bu bilinen işlevler, tanımlanmış operatörleri verimli bir şekilde kullanarak girdi alır ve çıktıyı görüntüler.

Geçmişi göz önüne alındığında, STL başlangıçta Standart Şablon Kitaplığı olarak adlandırıldı. Ardından, STL kitaplığının bölümleri, günümüzde kullanılan C++ Standart Kitaplığı'nda standartlaştırıldı. Bunlar, ISO C++ çalışma zamanı kitaplığını ve diğer bazı önemli işlevleri içeren Boost kitaplığından birkaç parçayı içerir. Bazen STL, kapsayıcıları veya daha sık olarak C++ Standart Kitaplığının algoritmalarını belirtir. Şimdi, bu STL veya Standart Şablon Kitaplığı, tamamen bilinen C++ Standart Kitaplığı hakkında konuşuyor.

std ad alanı ve başlık dosyaları:

Fonksiyonların veya değişkenlerin tüm bildirimleri, aralarında eşit olarak dağıtılan başlık dosyalarının yardımıyla standart kitaplık içinde yapılır. Başlık dosyalarını dahil etmediğiniz sürece bildirim gerçekleşmez.

Birinin listeleri ve dizeleri kullandığını varsayalım, aşağıdaki başlık dosyalarını eklemesi gerekiyor:

Bu köşeli parantezler '<>', bu belirli başlık dosyasının tanımlanan ve dahil edilen dizinde aranması gerektiğini belirtir. Gerekirse veya istenirse yapılan bu kütüphaneye bir '.h' uzantısı da eklenebilir. '.h' kitaplığını hariç tutarsak, bu başlık dosyasının bir C kitaplığına ait olduğunun bir göstergesi olarak, dosya adının başlangıcından hemen önce bir 'c' ekine ihtiyacımız var. Örneğin, (#include veya #include ) yazabilirsiniz.

Ad alanından bahsetmişken, tüm C++ standart kitaplığı, std olarak belirtilen bu ad alanının içinde yer alır. Standartlaştırılmış kitaplık adlarının kullanıcılar tarafından yetkin bir şekilde tanımlanmasının nedeni budur. Örneğin:

C++ Vektörleri:

C++'da veri veya değerleri saklamanın birçok yolu vardır. Ama şimdilik, programları C++ dilinde yazarken değerleri saklamanın en kolay ve en esnek yolunu arıyoruz. Dolayısıyla vektörler, boyutları, öğelerin eklenmesine ve çıkarılmasına bağlı olarak yürütme sırasında değişen bir seri modelde düzgün şekilde sıralanan kaplardır. Bu, programcının programın yürütülmesi sırasında vektörün boyutunu isteğine göre değiştirebileceği anlamına gelir. Dizilere, içerdikleri öğeler için iletilebilir depolama konumlarına sahip olacakları şekilde benzerler. Vektörlerin içinde bulunan değerlerin veya öğelerin sayısını kontrol etmek için bir ' kullanmamız gerekir. standart::saymak' işlev. Vektörler, C++'ın Standart Şablon Kitaplığına dahil edilmiştir, bu nedenle öncelikle dahil edilmesi gereken belirli bir başlık dosyasına sahiptir:

Beyanname:

Bir vektörün bildirimi aşağıda gösterilmiştir.

Burada vektör kullanılan anahtar kelimedir, DT vektörün int, float, char veya diğer ilgili veri türleri ile değiştirilebilen veri türünü gösterir. Yukarıdaki beyan şu şekilde yeniden yazılabilir:

Yürütme sırasında boyut artabileceği veya azalabileceği için vektörün boyutu belirtilmemiştir.

Vektörlerin Başlatılması:

Vektörlerin başlatılması için C++'da birden fazla yol vardır.

Teknik numarası 1:

Bu prosedürde, her iki vektör için de değerleri doğrudan atadık. Her ikisine de atanan değerler tamamen benzerdir.

Teknik numarası 2:

Bu başlatma işleminde, 3 vektörün boyutunu belirler ve 15, içinde depolanan veri veya değerdir. 15 değerini depolayan 3 boyutunda bir veri türü 'int' vektörü oluşturulur; bu, 'v3' vektörünün aşağıdakileri depoladığı anlamına gelir:

Başlıca işlemler:

Vektör sınıfı içindeki vektörler üzerinde gerçekleştireceğimiz başlıca işlemler şunlardır:

• değer ekleme
• Bir değere erişme
• Bir değeri değiştirme
• Bir değeri silme

Ekleme ve silme:

Vektörün içindeki elemanların eklenmesi ve çıkarılması sistematik olarak yapılır. Çoğu durumda, öğeler vektör kaplarının bitişine eklenir, ancak istediğiniz yere, sonunda diğer öğeleri yeni konumlarına kaydıracak değerler de ekleyebilirsiniz. Silme işleminde ise değerler son konumdan silindiğinde otomatik olarak kapsayıcı boyutunu küçültecektir. Ancak kap içindeki değerler belirli bir konumdan rastgele silindiğinde, yeni konumlar diğer değerlere otomatik olarak atanır.

Kullanılan fonksiyonlar:

Vektörün içinde saklanan değerleri değiştirmek veya değiştirmek için değiştiriciler olarak bilinen önceden tanımlanmış bazı işlevler vardır. Bunlar aşağıdaki gibidir:

• Insert(): Belirli bir konumda bir vektör konteynerinin içine bir değer eklemek için kullanılır.
• Erase(): Belirli bir lokasyondaki bir vektör konteynırının içindeki bir değerin kaldırılması veya silinmesi için kullanılır.
• Swap(): Aynı veri tipine ait bir vektör konteyneri içindeki değerlerin takası için kullanılır.
• Assign(): Vektör kapsayıcısında daha önce saklanan değere yeni bir değer atanması için kullanılır.
• Begin(): İlk eleman içindeki vektörün ilk değerini ele alan bir döngü içinde bir yineleyici döndürmek için kullanılır.
• Clear(): Bir vektör kapsayıcısında saklanan tüm değerlerin silinmesi için kullanılır.
• Push_back(): Vektör konteynerinin bitiminde bir değerin eklenmesi için kullanılır.
• Pop_back(): Vektör konteynerinin bitiminde bir değerin silinmesi için kullanılır.

Örnek:

Bu örnekte, vektörler boyunca değiştiriciler kullanılmıştır.

İlk olarak, ve başlık dosyalarını ekliyoruz. Bundan sonra, sınıfları bir kerede eklemek için ad alanı std entegre edilir. Tüm programın mantığını yazmak için, 'digits' adlı bir vektörün başlatıldığı main() işlevini çağırıyoruz. Bu vektörün ataması, 'rakamların' 6 ve 24 değerini verdiği bir sonraki adımda yapılır; bu, vektör kabının içinde her biri 24 değerine sahip 6 öğenin depolandığı anlamına gelir. Bu değerler daha sonra 'cout' kullanılarak görüntülenir. ' emretmek. Konteyner içindeki öğelerin eklenmesi için push_back() değiştirici işlevi için bir 'for' döngüsü kullanılır. Şimdi, sondaki rakamlara 3 değer eklenir. Vektör kabının boyutunun kaydını tutmak için bir 'x' değişkeni başlatıyoruz. Şimdi, son elemanın değeri görüntülenir ve pop_back() işlev, kap içinde saklanan '3' sayısını siler. Tüm öğelerin görüntülenmesi için, tekrar bir 'for' döngüsü kullanıyoruz. sokmak() değerleri ekleyecek değiştirici. Burada, vektör konteynerinin başına 4 eklenecek ve ekranda görüntülenecektir. bu açık() değiştirici daha sonra kap içinde depolanan tüm değerleri siler veya siler. Temizleme işlemi tamamlandıktan sonra vektörün boyutu gösterilir.

Çıktı aşağıda gösterilmiştir.

C++ Dosyaları Giriş Çıkışı:

Dosya, birbiriyle ilişkili verilerin bir derlemesidir. C++'da dosya, kronolojik sırada bir araya toplanan bir bayt dizisidir. Dosyaların çoğu diskin içinde bulunur. Ancak manyetik bantlar, yazıcılar ve iletişim hatları gibi donanım aygıtları da dosyalara dahildir.

Dosyalardaki giriş ve çıkış, üç ana sınıfla karakterize edilir:

• Girdi almak için 'istream' sınıfı kullanılır.
• Çıktıyı görüntülemek için 'ostream' sınıfı kullanılır.
• Giriş ve çıkış için 'iostream' sınıfını kullanın.

Dosyalar, C++'da akışlar olarak işlenir. Bir dosyadan veya bir dosyadan girdi ve çıktı alırken kullanılan sınıflar şunlardır:

• Yayın dışı: Bir dosyaya yazmak için kullanılan bir akış sınıfıdır.
• if akışı: Bir dosyadan içerik okumak için kullanılan bir akış sınıfıdır.
• Aktarım: Bir dosyadan veya bir dosyadan hem okumak hem de yazmak için kullanılan bir akış sınıfıdır.

'istream' ve 'ostream' sınıfları, yukarıda bahsedilen tüm sınıfların atalarıdır. Dosya akışlarının kullanımı 'cin' ve 'cout' komutları kadar kolaydır, yalnızca bu dosya akışlarını diğer dosyalarla ilişkilendirme farkı vardır. 'fstream' sınıfı hakkında kısaca çalışmak için bir örnek görelim:

Örnek:

Bu durumda, bir dosyaya veri yazıyoruz.

İlk adımda giriş ve çıkış akışını entegre ediyoruz. Dosyadan veri yazıp okuyacağımız için başlık dosyası eklenir. Bundan sonra, sınıflar namespace yardımıyla çağrılır. bu ana() işlevi, verileri bir dosyaya yazan 'ofstream'in kullanıldığı programın gövdesi için çağrılır, dosya New_File olarak oluşturulur. Bir sonraki adımda, 'example' adlı bir metin dosyası açıyoruz. açık( ) yöntem. Dosyanın içine köşeli parantezler yardımıyla bir metin yazıyoruz. Her dosya, ele alındıktan sonra kapatılmaya mahkumdur. Bu nedenle dosya yardımı ile kapatılır. kapat() işlev.

Kişisel bilgisayardan ‘örnek’ dosyası açılır ve dosyaya yazılan metin yukarıda gösterildiği gibi bu metin dosyasına yazdırılır.

Dosya açma:

Bir dosya açıldığında, bir akış ile temsil edilir. Önceki örnekte oluşturulan New_File gibi dosya için bir nesne oluşturulur. Akışta yapılan tüm giriş ve çıkış işlemleri otomatik olarak dosyanın kendisine uygulanır. Bir dosyanın açılması için open() işlevi şu şekilde kullanılır:

Burada, mod zorunlu değildir.

Bir dosyayı kapatma:

Tüm giriş çıkış işlemleri bittikten sonra düzenleme için açılan dosyayı kapatmamız gerekiyor. istihdam etmek zorundayız kapat() bu durumda işlev görür.

Bu yapıldığında, dosya kullanılamaz hale gelir. Herhangi bir koşulda nesne yok edilirse, dosyaya bağlı olsa bile, yok edici kendiliğinden close() işlevini çağırır.

Metin dosyaları:

Metin dosyaları, metni depolamak için kullanılır. Bu nedenle, metin girilir veya görüntülenirse, bazı biçimlendirme değişiklikleri olacaktır. Metin dosyasının içindeki yazma işlemi, 'cout' komutunu yaptığımızla aynıdır.

Örnek:

Bu senaryoda, önceki resimde zaten yapılmış olan metin dosyasına veri yazıyoruz.

Burada New_File() fonksiyonunu kullanarak 'example' isimli dosyaya veri yazıyoruz. 'Örnek' dosyasını kullanarak açıyoruz. açık() yöntem. Verileri dosyaya eklemek için 'ofstream' kullanılır. Dosya içindeki tüm işlemler yapıldıktan sonra, gerekli dosya kullanılarak dosya kapatılır. kapat() işlev. Dosya açılmazsa 'Dosya desteklenmiyor, dosya yüklenirken hata oluştu' hata mesajı gösterilir.

Dosya açılır ve metin konsolda görüntülenir.

Bir metin dosyasını okuma:

Bir dosyanın okunuşu aşağıdaki örnek yardımıyla gösterilmiştir.

Örnek:

Dosya içinde saklanan verileri okumak için 'ifstream' kullanılır.

Örnek, başlangıçta ana başlık dosyalarını içerir. Ardından, içinde 'ifstream' kullanın ana() işlev. 'ifstream' yardımı ile, 'example' metin dosyasının içinde saklanan metni gösteren 'New_File' dosyası ile verileri okuyacağız. biz istihdam açık() Dosyayı açma yöntemi. Ardından, 'while' döngüsünü kullanacağız. 'Örnek' metin dosyasındaki verileri okuduktan sonra, kapat() işlevi gerekli dosyayı kapatmak için kullanılır. Sistem belirli bir dosyaya sahip değilse, 'Dosya açılamıyor' mesajını alıyoruz.

Metin dosyasında saklanan tüm bilgiler, gösterildiği gibi ekranda görüntülenir.

Çözüm

Yukarıdaki kılavuzda, C++ dilini ayrıntılı olarak öğrendik. Örneklerle birlikte her konu gösterilir ve açıklanır ve her eylem detaylandırılır.