**C++** (/ˈsiː plʌs plʌs/, telaffuz: *si pılas pılas*), Bell Laboratuvarlarından Bjarne Stroustrup tarafından 1979 yılından itibaren geliştirilmeye başlanmış, C'yi kapsayan ve çok paradigmalı, yaygın olarak kullanılan, genel amaçlı bir programlama dilidir.

İlk olarak *C With Classes* (Sınıflarla C) olarak adlandırılmış, 1983 yılında ismi C++ olarak değiştirilmiştir. Günüzümüzde en çok kullanılan programlama dillerinden biri olmuştur.

C++ tasarlanırken C programlama dili ile olabildiğince uyumlu olması göz önüne bulundurulmuş ve *K&R2*'deki tüm örnek kodun derleneceği şekilde tasarlanmıştır.

C++, C'nin sağladığı alt seviye sıkı donanım desteğinin yanında farklı veri türleri, sınıf, şablon, sıradışı durum yönetimi, isim alanı (namespace), işleç fazladan yüklemesi, işlev fazladan yüklemesi, referans, hafıza yönetimi ve pek çok kütüphane imkanı sunar.

##### Standardizasyon

Bir programlama dilini oluşturan gramer, anlam ve standard kütüphane yapıları muğlak olmayacak bir biçimde belgelenir (spec veya specification) ve yayınlanır. Derleyici sağlayıcıları (vendor) bu belgeyi kullanarak derleyiciyi gerçekler.

C++ dilinin özelliklerini belirleyen bu belge (buradan sonrasında, standard) ISO / IEC Ortak Teknik Komitesi 1 (İng: *Joint Technical Committee 1, JTC1*) / Altkomite 22 (*Subcommittee 22, SC22*) Çalışma Grubu 21 (*Working Group 21, WG21*) (ISO/IEC JTC1/SC22/WG21) tarafından geliştirilir.

İlk standard 1998'de *ISO/IEC 14882:1998* adıyla yayınlandı. Sonrasında C++03, C++11, C++14, C++17 ve mevcut standard olan C++20 yayınlandı. 2012 sonrası üçer senelik periyotlarla yayınlanmaya başlanmıştır.

Dil
---

### Şablonlar

Şablonlar (template) tipten bağımsız olarak derleme zamanında parameterize fonksiyon veya sınıf yazılmasına izin verir ve jenerik programlamayı, şablon meta programlamayı, kod optimizasyonunu mümkün kılar. Şablon mekanizması Turing-tam'dır, böylece herhangi bir hesaplamanın bir şekilde derleme zamanında programlanarak ifade edilebilmesini sağlar.

### Nesneler

C++ nesne tanımlamada *RAII*(*Resource Acquisition Is Initialization*) tekniğini kullanır. Nesne için gerekli olan kaynak ayrımı (*Resource Acquisition*), tanımlandığı anda yapılır (*Initialization*) ve gerektiğinde deterministik olarak serbest bırakılır. Böylece kaynaklar init()/free(), allocate()/destroy(), open()/close() gibi fonksiyon çiftleriyle manuel olarak yönetilmek zorunda kalmaz.

#### Kapsamlama

Kapsamlama (encapsulation), veri yapısının geliştirici tarafından doğru bir şekilde kullanılacağından emin olmak için nesneye ait bilgilerin bir kısmını erişilemez yapmaktır. C++, sınıf yapısında üyelerin public, protected veya private tanımlanmasına izin verir. private üyeler yalnızca sınıfın üyeleri tarafından erişilebilir, böylece sınıfın kendisini ilgilendiren bazı üye değişken veya fonksiyonlar kullanıcıdan (client) saklanır. Ayrıca bu yolla nesnenin yaşamı süresince değişmemesi gereken durumlar (class invariant) korunabilir.

#### Kalıtlama

Kalıtlama (inheritence) var olan bir türün özelliklerini taşıyan yeni bir tür oluşturmayı sağlar. Temel sınıftan kalıtım, "public", "protected" ve "private" olarak ilan edilebilir. Diğer iki kalıtım türü arayüzün anlaşılmasını zorlaştırdığından çoğu zaman yalnızca public kalıtım kullanılır. Geçiş belirteci belirtilmezse, class private, struct public olarak kalıtılır.

Temel sınıftan kalıtım sanal (virtual) olarak ilan edilebilir, buna sanal kalıtım (virtual inheritence) denir. Sanal kalıtım çoklu kalıtımın problemlerinden sıyrılarak temel sınıfın yalnızca bir örneğinin kalıtım grafiğinde olmasını sağlar.

### İşleçlerin ve işlevlerin fazladan yüklenmesi

C++ dilinde işleçlerin (operator) çoğu fazladan yükleme yoluyla genelleştirilebilir. Örneğin + işleci sayılar için anlamlıyken, std::string sınıfı için de fazladan yüklenmiş, böylece türün temsil ettiği veriye + işleciyle birleştirilme yeteneği kazandırılmıştır. Benzer şekilde iki std::string sınıfı nesnesinin eşitliği == işleciyle kontrol edilebilir. Kullanıcı tanımlı herhangi bir tür (sınıf), işleçleri fazladan yükleyebilir.

Aynı isme sahip işlevler (function) farklı tür veya sayıda parametre alarak fazladan yüklenebilir. Örneğin std::to\_string fonksiyonu int, float ve double türleri için fazladan yüklenmiştir.

### Çokbiçimlilik

Çokbiçimlilik (polymorphism) kullanılarak farklı türler aynı arayüz üzerinden erişilebilir. Çokbiçimli bir tür kendisini oluşturan diğer türler gibi davranabilir. C++, dinamik (çalışma zamanında) ve statik (derleme zamanında) çokbiçimlilik çeşitlerine izin verir.

#### Dinamik çokbiçimlilik

##### Kalıtlama kullanılarak

Üst sınıfa işaret eden bir pointer veya ona ait bir referans, alt sınıfları da gösterebilir.
Bu durumda üst sınıf bir çokbiçimli türdür (polymorphic type). Eğer üst sınıf bir fonksiyona referans veya pointer şeklinde parametre olarak geçilirse, ondan türetilmiş sınıflar da geçilebilir. Üst sınıf üzerinden alt sınıfların üyeleri kullanılabilir. Alt sınıflardan hangisinin geçildiği dynamic\_cast kullanılarak belirlenebilir.

##### Sanal üye fonksiyonlar kullanarak

Türetilmiş sınıf, üst sınıfta sanal (virtual) olarak işaretlenmiş bir üye fonksiyonun içeriğini değiştirerek
tekrar gerçekleyebilir (override). Bu durumda çokbiçimli tür, tekrar gerçeklenen üye fonksiyonu çağıracaktır.

#### Statik çokbiçimlilik

Şablon yapısı farklı türler için parçalı veya tam özelleştirilerek parametrik çokbiçimlilik sağlanabilir.

İşlevlerin fazladan yüklenmesi de statik çokbiçimlilik olarak düşünülebilir. Aynı isme sahip fonksiyonlar, parametre türü veya sayısına göre farklı fonksiyonları çağırır.

### Lambda ifadeleri

C++ lambda ifadeleriyle anonim fonksiyon yazımını destekler.

```
[kapma](parametreler) -> dönüş\_tipi { fonksiyon\_gövdesi };

```

dönüş\_tipi düşürülebilir, bu durumda dönüş tipi gövdeden çıkarımsanır:

```
[kapma](parametreler) { fonksiyon\_gövdesi };

```

Lambda parametre almıyorsa, () yapısı düşürülebilir:

```
[kapma]{ fonksiyon\_gövdesi };

```

Lambda değişkene atanarak isim alabilir ve tekrar kullanılabilir:

```
auto func = [kapma](parametreler) { fonksiyon\_gövdesi };
func(argumanlar);
func(argumanlar);

```

Lambda tanımlandığı anda çalıştırılıp hesaplama sonucuna erişilebilir:

```
auto result = [kapma](parametreler) { fonksiyon\_gövdesi }(argumanlar);

```

C++20 ile şablon (template) lambda ifadeleri yazılabilir:

```
[kapma] <template\_parametreler> (parametreler) -> dönüş\_tipi { fonksiyon\_gövdesi }

```

### Sıradışı durum yönetimi

Program çalışırken yolunda gitmeyen bir şey oluştuğunda ve programın aniden sonlandırılması arzu edilmiyorsa, sıradışı durum yönetimi (exception handling) kullanılarak ana koddan ayrı olarak yönetim sağlanabilir. Sıradışı durum (exception) oluştuğu yerde bir hata kodu fırlatır ve sıradışı durum yöneticisi (exception handler) tarafından yakalanana kadar kapsam dışana taşar. Eğer hata kodu yakalanmazsa program sonlandırılır.

Standard Kütüphane
------------------

C++ standard kütüphanesi (İng. Standard Template Library, STL) pek çok tutucu tür, algoritma, G/Ç, dosya sistemi, regex, multithread, zaman yönetimi, sıradışı durum yönetimi, rastgele sayı üreteci, C ile geriye dönük uyumluluk başlık dosyaları bulundurur.

C++ Core Guidelines
-------------------

C++ Core Guidelines (Türkçe, C++ Temel Yönelgeleri), C++ programcılarının daha basit, daha etkili, daha yönetilebilir kod yazmalarını sağlamayı hedefleyen yönelgeleri içeren bir projedir. Projenin editörlüğünü dilin yaratıcısı Bjarne Stroustrup ile ISO C++ Çalışma Grubu başkanı Herb Sutter sürdürür.

Core guidelines pek çok stil, iyi uygulama ve modern C++ tavsiyeleri bulundurur. Statik analiz araçları bu tavsiyeleri gerçekleyerek kod yazılırken programcıları kötü uygulamalardan kaçınmasına yardımcı olur.

Guideline Support Library (GSL), Core Guidelines'ta tavsiye edilen pek çok tür ve fonksiyonu barındıran bir kütüphanedir.

Derleme modeli
--------------

C++ çoğunlukla derlenen bir dil olarak gerçeklenmiştir. Kaynak kodun derlenme süreci dört aşamadan oluşur, sırasıyla; önişleme, derleme, assembly ve bağlama. Derleyici kaynak koda uygulandığında bu aşamalar birbiri ardına gerçekleşir.

* Önişlemci (preprocessor) #include direktifiyle eklenen dosyaları koda taşır. Ayrıca kodda sözcük değişiklikleri yapabilir, koşullu derleme sağlayabilir, derleyicinin bir takım özelliklerini kontrol edebilir veya kodun derleneceği platform hakkında bilgi alabilir.
* Derleyici (compiler veya compiler proper) kodu parçalara ayırır, sözdizimi ve anlamı analiz eder, hataları bildirir, optimize eder ve işlemcinin sahip olduğu mimarinin assembly koduna derler.
* Assembly kodu assembler tarafından yerdeğiştirebilir (relocatable object code) hedef koduna dönüştürülür.
* Bağlayıcı (linker) yerdeğiştirebilir hedef kodunu diğer hedef kodlarına (kütüphane vs.) bağlar ve çalıştırılabilir hedef kodunu oluşturur.

Örnekler
--------

### Yorum Satırları

Yorum satırları derleyici tarafından çalıştırılmaz. Bunlar kodun anlaşılmasını kolaylaştırmak için eklenir.

```
// Tek satirdan olusan bir yorum
/\*
 Birden 
 fazla 
 satirdan olusan yorum
\*/

```

### Merhaba Dünya

Bu program uçbirim ekranına "Merhaba, dunya!" yazacaktır. 

```
#include <iostream>

int main() {
 std::cout << "Merhaba, dunya!\n";
}

```

### İşleçlerinin fazladan yüklenmesi

```
#include <iostream>

struct Complex {
 double real{};
 double imaginary{};

 Complex& operator+=(const Complex& other) {
 real += other.real, imaginary += other.imaginary;
 return \*this;
 }

 Complex& operator-=(const Complex& other) {
 real -= other.real, imaginary -= other.imaginary;
 return \*this;
 }

 friend std::istream& operator>>(std::istream& is, Complex& c) {
 return is >> c.real >> c.imaginary;
 }

 friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
 return os << c.real << '+' << c.imaginary << 'i' << '\n';
 }
};

Complex operator+(const Complex& l, const Complex& r) {
 return Complex{l.real + r.real, l.imaginary + r.imaginary};
}

Complex operator-(const Complex& l, const Complex& r) {
 return Complex{l.real - r.real, l.imaginary - r.imaginary};
}

int main() {
 Complex c;
 std::cout << c; // 0+0i

 Complex first{1, 0};
 std::cout << first; // 1+0i

 Complex second{0, 1};
 std::cout << second; // 0+1i

 first += second;
 std::cout << first; // 1+1i

 Complex result = first + second;
 std::cout << result; // 1+2i
}

```

### Lambda ifadeleri

```
#include <vector>
#include <iostream>
#include <range/v3/all.hpp>

int main() {
 using namespace ranges;
 // .-- boş kapma
 auto // | .-- parametre
 harmonic\_sum = views::iota(1)// v v v-- dönüş tipi
 | views::transform([](int n) -> double { return 1.0 / n; })
 | views::partial\_sum // lambda gövdesi-^-----------------^
 | views::take(10)
 | to<std::vector<double>>;

 for(auto [n, hn] : harmonic\_sum | views::enumerate)
 std::cout << n << ' ' << hn << '\n';
}

// 0 1
// 1 1.5
// 2 1.83333
// 3 2.08333
// ...

```

### Sıradışı durum yönetimi

```
#include <exception>
#include <filesystem>
#include <cstdio>

// kullanicilar std::exception'i kalitlayarak 
// kendi siradisi durum tipini tanimlar
struct appUsageError : std::exception {
 [[nodiscard]] const char \*what() const noexcept override {
 return "Usage: mkdir directory";
 }
};

int main(int argc, const char \*const argv[]) {
 try {
 if (argc != 2)
 throw appUsageError{};

 // noexcept degil, filesystem\_error hatasi firlatabilir
 // https://en.cppreference.com/w/cpp/filesystem/create\_directory
 std::filesystem::create\_directory(argv[1]);

 } catch (const appUsageError &e) {
 puts(e.what());
 } catch (const std::filesystem::filesystem\_error &e) {
 puts(e.what());
 } catch (const std::exception &e) {
 puts(e.what());
 }
}
// c++ -std=c++17 main.cpp -o mkdir
// ./mkdir
// Usage: mkdir directory
// ./mkdir /usr/local/Folder
// filesystem error: cannot create directory: Permission denied [/usr/local/Folder]
// ./mkdir Folder 
// # Folder adinda bir dizin hatasiz olusturuldu

```

Ayrıca bakınız
--------------

* C tabanlı programlama dilleri listesi

Dipnotlar
---------

1. ↑  ++ sonek işleci C programlama dilinde sayısal bir değişkenin değerini bir artırmak anlamındadır.

Kaynakça
--------

1. ↑  "ISO/IEC 14882:1998". *ISO*. 15 Ocak 2017 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
2. ↑  "ISO/IEC 14882:2003". *ISO*. 13 Ocak 2017 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
3. ↑  "ISO/IEC 14882:2011". *ISO*. 30 Ocak 2017 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
4. ↑  "ISO/IEC 14882:2014". *ISO*. 29 Nisan 2016 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
5. ↑  "ISO/IEC 14882:2017". *ISO*. 29 Ocak 2013 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
6. ↑  "ISO/IEC 14882:2020". *ISO*. 16 Aralık 2020 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
7. ↑  "ISO/IEC PRF 14882". *ISO*. 28 Ocak 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 10 Şubat 2024.
8. ↑  "History of C++" (İngilizce). 28 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 22 Şubat 2024.
9. ↑  "From the archives: "C++: as close as possible to C -- but no closer" -- A. Koenig and B. Stroustrup : Standard C++". *isocpp.org*. 15 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 15 Şubat 2024.
10. ↑  Stroustrup, Bjarne (29 Mart 1994). *Design and Evolution of C++*. Addison-Wesley Professional. s. 101. ISBN 9780201543308. 4 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 28 Şubat 2024.
11. ↑  "open-std.org". 27 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 27 Şubat 2024.
12. ↑  "Şablonlar". 24 Mayıs 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 30 Ocak 2024.
13. ↑  "RAII" (İngilizce). 21 Mart 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 21 Mart 2024.
14. ↑  TylerMSFT (16 Haziran 2023). "İşleç Aşırı Yüklemesi". *learn.microsoft.com*. 25 Ağustos 2023 tarihinde kaynağından arşivlendi. Erişim tarihi: 25 Ağustos 2023.
15. ↑  "Lambda". 21 Ocak 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 29 Ocak 2024.
16. ↑  "Standard Kütüphane". 3 Aralık 2023 tarihinde kaynağından arşivlendi. Erişim tarihi: 30 Ocak 2024.
17. ↑  "C++ Core Guidelines" (İngilizce). 29 Şubat 2024. 29 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 29 Şubat 2024.
18. ↑  "Guideline Support Library" (İngilizce). 29 Şubat 2024. 29 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 29 Şubat 2024.
19. ↑  "How does the compilation linking process work?". 10 Şubat 2024 tarihinde kaynağından arşivlendi. Erişim tarihi: 9 Şubat 2024.
20. ↑  TylerMSFT (16 Haziran 2023). "Ön işlemci dil bilgisi özeti (C/C++)". *learn.microsoft.com*. 25 Ağustos 2023 tarihinde kaynağından arşivlendi. Erişim tarihi: 25 Ağustos 2023.
21. ↑  "Yorum satırı". 28 Kasım 2023 tarihinde kaynağından arşivlendi. Erişim tarihi: 30 Ocak 2024.

Dış bağlantılar
---------------

VikikitapVikikitap
Vikikitapta bu konu hakkında daha fazla bilgi var:
***C++***

* Standart C++'ı Yeni Bir Dil Olarak Öğrenmek8 Nisan 2014 tarihinde Wayback Machine sitesinde arşivlendi.—Bjarne Stroustrup'un yazısının çevirisi

* C++ reference 1 Mart 2024 tarihinde Wayback Machine sitesinde arşivlendi. (İngilizce)

* Cplusplus.com1 Mart 2024 tarihinde Wayback Machine sitesinde arşivlendi. (İngilizce)

* C++ Super-FAQ1 Mart 2024 tarihinde Wayback Machine sitesinde arşivlendi. (İngilizce)

* C++ Language Reference 1 Mart 2024 tarihinde Wayback Machine sitesinde arşivlendi. (İngilizce)

* Hacking C++ — Çağdaş C++ Öğrenin 15 Şubat 2024 tarihinde Wayback Machine sitesinde arşivlendi. (İngilizce)

| * g
* t
* d
Tümleşik geliştirme ortamları (IDE) |
| --- |
| C ve C++ | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Android Studio
* Anjuta
* Code::Blocks
* CodeLite
* Dev-C++
* Eclipse
* Emacs
* Geany
* GNAT Programming Studio
* GNOME Builder
* KDevelop
* MonoDevelop
* NetBeans
* TheIDE
* QDevelop
* Qt Creator
* SharpDevelop
* Vi/Vim
* OpenWatcom

 |
| Freeware | 
* Oracle Developer Studio
* Visual Studio Community
* Xcode

 |
| Perakende | 
* C++Builder
* Eclipse-tabanlı
	+ CodeWarrior
	+ MyEclipse
* Visual Studio
* JetBrains tarafından
	+ IntelliJ IDEA
	+ AppCode
	+ CLion
* LabWindows/CVI
* IBM Rational Software Architect
* Understand
* SlickEdit

 |
| Durduruldu | 
* VisualAge
* Visual C++ Express
* Borland Turbo C / C++

 |

 |
| Java | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Anjuta
* BlueJ
* DrJava
* Eclipse
* Geany
* Greenfoot
* IntelliJ IDEA Community Edition
	+ Android Studio
* NetBeans
* Servoy Community Edition

 |
| Freeware | 
* jGRASP
* JDeveloper

 |
| Perakende | 
* JCreator
* MyEclipse
* IBM
	+ WebSphere Integration Developer
* JetBrains IntelliJ IDEA
* Servoy Business Application Platform Edition
* SlickEdit
* Understand

 |
| Durduruldu | 
* Metrowerks CodeWarrior Pro for Java
* JBuilder
* Sun Java Studio Creator (yerini NetBeans aldı)
* VisualAge (yerini Eclipse aldı)
* Visual Café (Espresso olarak da bilinir, yerini JBuilder aldı)
* Visual J++
* Xelfi (NetBeans oldu)

 |

 |
| JavaScript | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Vim
* Visual Studio Code
* Atom
* Chromium

 |

 |
| CLI | 

|  |  |
| --- | --- |
| Açık kaynak | 
* MonoDevelop
* SharpDevelop
* Visual Studio Code
* PascalABC.NET

 |
| Freeware | 
* Visual Studio Community

 |
| Perakende | 
* Visual Studio
* Rider
* Understand

 |
| Durduruldu | 
* Xamarin Studio
* Visual Basic Express
* Visual Web Developer Express
* Visual J# Express
* Visual Studio Express for Windows Phone
* Visual C++ Express
* Visual C# Express
* Express for Desktop
* Express for Web
* Express for Windows

 |

 |
| Flash | 
* Adobe Flash Builder
* FlashDevelop
* Powerflasher FDT

 |
| PHP | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Aptana
* NetBeans
* Komodo Edit
* Komodo IDE
* KDevelop

 |
| Tescilli | 
* Codelobster
* PhpStorm
* PHPEdit
* SlickEdit
* Zend Studio

 |

 |
| R | 
* RStudio
* R Tools for Visual Studio

 |
| Python | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Anjuta
* IDLE
* Eric
* Light Table
* Ninja-IDE
* PyDev
* PyScripter
* PIDA
* Spyder
* Komodo Edit
* Komodo IDE
* KDevelop
* Vim
* Visual Studio Code
* Thonny

 |
| Tescilli | 
* PyCharm
* PythonAnywhere
* SlickEdit
* Wing IDE

 |

 |
| Pascal ve Object Pascal | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Free Pascal IDE
* Lazarus
* Dev-Pascal
* GNAVI

 |
| Freeware | 
* Delphi Community

 |
| Perakende | 
* Delphi

 |
| Durduruldu | 
* Turbo Pascal
* Virtual Pascal
* Borland Kylix

 |

 |
| BASIC | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Basic-256
* B4X
* MonoDevelop
* SharpDevelop
* Microsoft Small Basic
* SdlBasic
* Gambas
* HBasic
* Basic For Qt
* Basic4GL
* QB64

 |
| Freeware | 
* FutureBASIC
* RapidQ
* thinAir
* Visual Studio Community

 |
| Perakende | 
* Visual Studio
* NS Basic
* PureBasic
* GLBasic
* Liberty BASIC
* Xojo

 |
| Durduruldu | 
* CA-Realizer
* Phoenix Object Basic
* QuickBASIC
* QBasic
* Visual Basic
* Visual Basic Express

 |

 |
| Go | 

|  |  |
| --- | --- |
| Açık kaynak | 
* Vim
* Visual Studio Code (VSCode)
* Eclipse

 |
| Freeware | 
* LiteIDE
* The Go Playground
* Cloud9 IDE

 |
| Perakende | 
* GoLand

 |

 |
| Çevrimiçi | 
* AWS Cloud9 IDE
* Eclipse Che
* SourceLair

 |
| 
* **Kategori**
* **Karşılaştırma**

 |

| * g
* t
* d
ISO standartları |
| --- |
| ISO standartları / ISO romanizasyonları \ IEC standartları |
| 1-9999 | 
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 9
* 16
* 17
* 31
	+ -0
	+ -1
	+ -2
	+ -3
	+ -4
	+ -5
	+ -6
	+ -7
	+ -8
	+ -9
	+ -10
	+ -11
	+ -12
	+ -13
* 128
* 216
* 217
* 226
* 228
* 233
* 259
* 269
* 302
* 306
* 361
* 428
* 500
* 518
* 519
* 639
	+ -1
	+ -2
	+ -3
	+ -5
	+ -6
* 646
* 657
* 668
* 690
* 704
* 732
* 764
* 838
* 843
* 860
* 898
* 965
* 999
* 1000
* 1004
* 1007
* 1073-1
* 1155
* 1413
* 1538
* 1745
* 1745
* 1989
* 2014
* 2015
* 2022
* 2033
* 2047
* 2108
* 2145
* 2146
* 2240
* 2281
* 2533
* 2709
* 2711
* 2720
* 2788
* 2848
* 2852
* 3029
* 3103
* 3166
	+ -1
	+ -2
	+ -3
* 3297
* 3307
* 3601
* 3602
* 3864
* 3901
* 3950
* 3977
* 4031
* 4157
* 4165
* 4217
* 4909
* 5218
* 5426
* 5427
* 5428
* 5725
* 5775
* 5776
* 5800
* 5807
* 5964
* 6166
* 6344
* 6346
* 6385
* 6425
* 6429
* 6438
* 6523
* 6709
* 6943
* 7001
* 7002
* 7010
* 7027
* 7064
* 7098
* 7185
* 7200
* 7498
* 7637
* 7736
* 7810
* 7811
* 7812
* 7813
* 7816
* 8000
* 8093
* 8178
* 8217
* 8373
* 8501-1
* 8571
* 8583
* 8601
* 8613
* 8632
* 8651
* 8652
* 8691
* 8807
* 8820-5
* 8859
	+ -1
	+ -2
	+ -3
	+ -4
	+ -5
	+ -6
	+ -7
	+ -8
	+ -8-I
	+ -9
	+ -10
	+ -11
	+ -12
	+ -13
	+ -14
	+ -15
	+ -16
* 8879
* 9000/9001
* 9036
* 9075
* 9126
* 9141
* 9227
* 9241
* 9293
* 9314
* 9362
* 9407
* 9506
* 9529
* 9564
* 9592-9593
* 9594
* 9660
* 9797-1
* 9897
* 9899
* 9945
* 9984
* 9985
* 9995

 |
| 10000-19999 | 
* 10006
* 10007
* 10116
* 10118-3
* 10160
* 10161
* 10165
* 10179
* 10206
* 10218
* 10303
	+ -11
	+ -21
	+ -22
	+ -28
	+ -238
* 10383
* 10487
* 10585
* 10589
* 10646
* 10664
* 10746
* 10861
* 10957
* 10962
* 10967
* 11073
* 11170
* 11179
* 11404
* 11544
* 11783
* 11784 & 11785
* 11801
* 11889
* 11898
* 11940 (-2)
* 11941 (TR)
* 11992
* 12006
* 12182
* 12207
* 12234-2
* 13211
	+ -1
	+ -2
* 13216
* 13250
* 13399
* 13406-2
* 13450
* 13485
* 13490
* 13567
* 13568
* 13584
* 13616
* 14000
* 14031
* 14224
* 14289
* 14396
* 14443
* 14496
	+ -2
	+ -3
	+ -6
	+ -10
	+ -11
	+ -12
	+ -14
	+ -17
	+ -20
* 14644
* 14649
* 14651
* 14698
* 14750
* 14764
* 14882
* 14971
* 15022
* 15189
* 15288
* 15291
* 15292
* 15398
* 15408
* 15444
	+ -3
* 15445
* 15438
* 15504
* 15511
* 15686
* 15693
* 15706
	+ -2
* 15707
* 15897
* 15919
* 15924
* 15926
* 15926 WIP
* 15930
* 16023
* 16262
* 16355-1
* 16612-2
* 16750
* 16949 (TS)
* 17024
* 17025
* 17203
* 17369
* 17442
* 17799
* 18000
* 18004
* 18014
* 18245
* 18629
* 18916
* 19005
* 19011
* 19092 (-1
* -2)
* 19114
* 19115
* 19125
* 19136
* 19439
* 19500
* 19501
* 19502
* 19503
* 19505
* 19506
* 19507
* 19508
* 19509
* 19510
* 19600:2014
* 19752
* 19757
* 19770
* 19775-1
* 19794-5
* 19831

 |
| 20000+ | 
* 20000
* 20022
* 20121
* 20400
* 21000
* 21047
* 21500
* 21827:2002
* 22000
* 22300
* 22395
* 23270
* 23271
* 23360
* 24517
* 24613
* 24617
* 24707
* 25178
* 25964
* 26000
* 26262
* 26300
* 26324
* 27000 serisi
* 27000
* 27001
* 27002
* 27005
* 27006
* 27729
* 28000
* 29110
* 29148
* 29199-2
* 29500
* 30170
* 31000
* 32000
* 37001
* 38500
* 40500
* 42010
* 45001
* 50001
* 55000
* 80000
	+ -1
	+ -2
	+ -3

 |
| 
* Kategori Kategori

 |

| * g
* t
* d
Programlama dilleri |
| --- |
| 
* Karşılaştırma
* Zaman Çizelgesi
* Tarihçe

 |
| 
* Ada
* ALGOL
* APL
* Assembly
* BASIC
* C
* C++
* C#
* Classic Visual Basic
* COBOL
* Erlang
* Forth
* Fortran
* Go
* Haskell
* Java
* JavaScript
* Kotlin
* Lisp
* Lua
* MATLAB
* ML
* Object Pascal
* Pascal
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* SQL
* Scratch
* Shell
* Simula
* Smalltalk
* Swift
* Visual Basic
* *dahası...*

 |
| 
* Liste **Listeler:** Alfabetik
* Kategoriik
* Nesilsel
* İngilizce temelli olmayan
* Kategori Kategori

 |

|  |  |
| --- | --- |
| Otorite kontrolü Bunu Vikiveri'de düzenleyin | 
* BNE: XX540250
* BNF: cb12139768z (data)
* GND: 4193909-8
* LCCN: sh87007505
* NKC: ph116956
* NLI: 987007539277905171
* SUDOC: 029859778

 |