C ++, ben yemiyorum ne için ödeme yapıyorum?

C ve C ++ 'da aşağıdaki merhaba dünya örneklerini ele alalım:

main.c

#include <stdio.h>

int main()
{
    printf("Hello world\n");
    return 0;
}

main.cpp

#include <iostream>

int main()
{
    std::cout<<"Hello world"<<std::endl;
    return 0;
}

Onları montaj için godbolt içinde derlediğimde, C kodunun boyutu sadece 9 satır ( gcc -O3):

.LC0:
        .string "Hello world"
main:
        sub     rsp, 8
        mov     edi, OFFSET FLAT:.LC0
        call    puts
        xor     eax, eax
        add     rsp, 8
        ret

Ancak C ++ kodunun boyutu 22 satırdır ( g++ -O3):

.LC0:
        .string "Hello world"
main:
        sub     rsp, 8
        mov     edx, 11
        mov     esi, OFFSET FLAT:.LC0
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)
        xor     eax, eax
        add     rsp, 8
        ret
_GLOBAL__sub_I_main:
        sub     rsp, 8
        mov     edi, OFFSET FLAT:_ZStL8__ioinit
        call    std::ios_base::Init::Init() [complete object constructor]
        mov     edx, OFFSET FLAT:__dso_handle
        mov     esi, OFFSET FLAT:_ZStL8__ioinit
        mov     edi, OFFSET FLAT:_ZNSt8ios_base4InitD1Ev
        add     rsp, 8
        jmp     __cxa_atexit

... çok daha büyük.

C ++ 'da ne yediğinizi ödediğiniz ünlüdür. Peki, bu durumda, ne için para ödüyorum?

Sizin için ödediğiniz şey ağır bir kütüphane (konsola yazdırmak kadar ağır değil) çağırmaktır. Bir ostreamnesneyi başlatırsınız . Bazı gizli depolama alanları var. Sonra, std::endleşanlamlı olmayan bir çağrı \n. iostreamKütüphane birçok ayarlarını değiştirerek ve programcı ziyade işlemci üzerindeki yükü koyarak yardımcı olur. Bu sizin için ödüyoruz.

Kodu gözden geçirelim:

.LC0:
        .string "Hello world"
main:

Bir ostream nesnesi + cout'u başlatma

    sub     rsp, 8
    mov     edx, 11
    mov     esi, OFFSET FLAT:.LC0
    mov     edi, OFFSET FLAT:_ZSt4cout
    call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)

coutYeni bir satır yazdırmak ve yıkamak için tekrar arama

    mov     edi, OFFSET FLAT:_ZSt4cout
    call    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)
    xor     eax, eax
    add     rsp, 8
    ret

Statik depolama başlatma:

_GLOBAL__sub_I_main:
        sub     rsp, 8
        mov     edi, OFFSET FLAT:_ZStL8__ioinit
        call    std::ios_base::Init::Init() [complete object constructor]
        mov     edx, OFFSET FLAT:__dso_handle
        mov     esi, OFFSET FLAT:_ZStL8__ioinit
        mov     edi, OFFSET FLAT:_ZNSt8ios_base4InitD1Ev
        add     rsp, 8
        jmp     __cxa_atexit

Ayrıca, dil ile kütüphane arasında ayrım yapmak da şarttır.

BTW, bu hikayenin sadece bir parçası. Aradığınız işlevlerde ne yazıldığını bilmiyorsunuz.

Peki, bu durumda, ne için para ödüyorum?

std::coutdaha güçlü ve karmaşıktır printf. Yerel ayarlar, durum bilgisi olan biçimlendirme bayrakları ve daha fazlasını destekler.

O, kullanımını gerekmiyorsa std::printfveya std::puts- Onlar kullanılabilir in <cstdio>.

C ++ 'da ne yediğinizi ödediğiniz ünlüdür.

Ayrıca C ++ ! = C ++ Standart Kütüphanesi'ni açıklığa kavuşturmak istiyorum . Standart Kütüphane genel amaçlı ve "yeterince hızlı" olmalıdır, ancak genellikle ihtiyacınız olan şeylerin özel bir uygulamasından daha yavaş olacaktır.

Öte yandan, C ++ dili, gereksiz ekstra gizli maliyetler ödemeden kod yazmayı mümkün kılmaya çalışır (örneğin, kaydolma virtual, çöp toplama yok).

C ve C ++ karşılaştırmıyorsunuz. Sen karşılaştırdığınız printfve std::coutfarklı şeyler (yerel, durum bilgisi biçimlendirme, vs) yeteneğine sahip olan.

Karşılaştırma için aşağıdaki kodu kullanmaya çalışın. Godbolt her iki dosya için aynı montajı oluşturur (gcc 8.2, -O3 ile test edilmiştir).

main.c:

#include <stdio.h>

int main()
{
    int arr[6] = {1, 2, 3, 4, 5, 6};
    for (int i = 0; i < 6; ++i)
    {
        printf("%d\n", arr[i]);
    }
    return 0;
}

main.cpp:

#include <array>
#include <cstdio>

int main()
{
    std::array<int, 6> arr {1, 2, 3, 4, 5, 6};
    for (auto x : arr)
    {
        std::printf("%d\n", x);
    }
}

Girişleriniz gerçekten elma ve portakalları karşılaştırıyor, ancak diğer cevapların çoğunda ima edilen sebepten dolayı değil.

Kodunuzun gerçekte ne yaptığını kontrol edelim:

C:

• tek bir dize yazdırmak, "Hello world\n"

C ++:

• dizeyi "Hello world"içine akıtmakstd::cout
• std::endlmanipülatör içine akışıstd::cout

Görünüşe göre C ++ kodunuz iki kat daha fazla iş yapıyor. Adil bir karşılaştırma için bunu birleştirmeliyiz:

#include <iostream>

int main()
{
    std::cout<<"Hello world\n";
    return 0;
}

… Ve birden bire montaj kodunuz mainC'lere çok benziyor:

main:
        sub     rsp, 8
        mov     esi, OFFSET FLAT:.LC0
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
        xor     eax, eax
        add     rsp, 8
        ret

Aslında, C ve C ++ kodunu satır satır karşılaştırabiliriz ve çok az fark vardır :

sub     rsp, 8                      sub     rsp, 8
mov     edi, OFFSET FLAT:.LC0   |   mov     esi, OFFSET FLAT:.LC0
                                >   mov     edi, OFFSET FLAT:_ZSt4cout
call    puts                    |   call    std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
xor     eax, eax                    xor     eax, eax
add     rsp, 8                      add     rsp, 8
ret                                 ret

Tek gerçek fark, C ++ ' operator <<da iki argüman ( std::coutve dize) ile çağırmamızdır . fprintfAkışı belirten ilk argümana sahip daha yakın bir C eşdeğeri: kullanarak bu ufak farkı bile kaldırabiliriz .

Bu _GLOBAL__sub_I_main, C ++ için oluşturulan ancak C değil için derleme kodunu bırakır . Bu, bu derleme listesinde görünen tek gerçek ek yüktür (elbette her iki dil için daha fazla görünmez ek yük vardır ). Bu kod, C ++ programının başlangıcında bazı C ++ standart kitaplık işlevlerinin bir kerelik kurulumunu gerçekleştirir.

Ancak, diğer cevaplarda açıklandığı gibi, bu iki program arasındaki ilgili fark, maintüm ağır kaldırma sahnelerin arkasında gerçekleştiğinden , işlevin montaj çıktısında bulunmaz .

C ++ 'da ne yediğinizi ödediğiniz ünlüdür. Peki, bu durumda, ne için para ödüyorum?

Bu basit. Ödersiniz std::cout. "Sadece ne yediğinize para ödersiniz", "her zaman en iyi fiyatları alırsınız" anlamına gelmez. Tabii, printfdaha ucuz. Bunun std::coutdaha güvenli ve çok yönlü olduğu iddia edilebilir , bu nedenle daha yüksek maliyeti haklıdır (daha pahalıya mal olur, ancak daha fazla değer sağlar), ancak bu noktayı kaçırır. Sen kullanmıyorsun printf, kullanıyorsun , kullandığın std::coutiçin ödüyorsun std::cout. Kullanmak için ödeme yapmazsınız printf.

Buna iyi bir örnek sanal işlevlerdir. Sanal işlevlerin bazı çalışma zamanı maliyeti ve alan gereksinimleri vardır - ancak bunları yalnızca gerçekten kullanıyorsanız. Sanal işlevleri kullanmazsanız, hiçbir şey ödemezsiniz.

Birkaç açıklama

1. C ++ kodu daha fazla montaj talimatı olarak değerlendirilse bile, yine de bir avuç talimatdır ve herhangi bir performans yükü hala gerçek G / Ç işlemleri tarafından engellenir.

2. Aslında, bazen daha iyi "C ++ ne yemek için ödeme". Örneğin, derleyici bazı durumlarda sanal işlev çağrısının gerekli olmadığını belirleyebilir ve bunu sanal olmayan çağrıya dönüştürebilir. Bu, sanal işlevleri ücretsiz alabileceğiniz anlamına gelir . Harika değil mi?

"Printf için montaj listesi" printf için DEĞİLDİR, ancak kotasyonlar için (derleyici optimizasyonu türü?); printf prety koyar çok daha karmaşık ... unutma!

Burada bazı geçerli cevaplar görüyorum, ancak biraz daha ayrıntıya gireceğim.

Bu metnin tüm duvarından geçmek istemiyorsanız, ana sorunuzun cevabı için aşağıdaki özete atlayın.

Soyutlama

Peki, bu durumda, ne için para ödüyorum?

Soyutlama için para ödüyorsun . Daha basit ve insan dostu kod yazmanın bir bedeli vardır. Nesneye yönelik bir dil olan C ++ 'da neredeyse her şey bir nesnedir. Herhangi bir nesneyi kullandığınızda, kaputun altında her zaman üç ana şey olacaktır:

1. Nesne oluşturma, temel olarak nesnenin kendisi ve verileri için bellek tahsisi.
2. Nesne başlatma (genellikle bazı init()yöntemlerle). Genellikle bellek tahsisi, bu adımdaki ilk şey olarak başlık altında gerçekleşir.
3. Nesne imhası (her zaman değil).

Kodda görmüyorsunuz, ancak bir nesneyi her kullandığınızda yukarıdaki üç şeyin hepsinin bir şekilde gerçekleşmesi gerekir. Eğer her şeyi manuel olarak yapacak olsaydınız, kod çok daha uzun olurdu.

Şimdi, soyutlama ek yükü eklemeden verimli bir şekilde yapılabilir: yöntem inlining ve diğer teknikler hem derleyiciler hem de programcılar tarafından soyutlama ek yüklerini kaldırmak için kullanılabilir, ancak bu sizin durumunuz değildir.

C ++ 'ta gerçekten neler oluyor?

İşte, ayrılmış:

1. std::ios_baseSınıf her I / ilgili O için temel sınıftır olan başlatılır.
2. std::coutNesne başlatılır.
3. Dizeniz yüklenir ve iletilir std::__ostream_insert(adıyla önceden anladığınız gibi ) akışa bir dize ekleyen bir yöntemdir std::cout(temel olarak <<operatör).
4. cout::endlde iletilir std::__ostream_insert.
5. __std_dso_handlegeçirilir __cxa_atexit, programdan çıkmadan önce "temizlik" sorumlu bir küresel işlev olan. __std_dso_handlekendisi bu işlev tarafından kalan küresel nesneleri yeniden konumlandırmak ve yok etmek için çağrılır.

Yani C == kullanarak hiçbir şey için ödeme yapmıyor musunuz?

C kodunda çok az adım gerçekleşiyor:

1. Dizeniz yüklenir ve kayıt putsaracılığıyla iletilir edi.
2. puts denir.

Hiçbir yerde nesne yok, dolayısıyla hiçbir şey başlatmaya / yok etmeye gerek yok.

Ancak bu, C'deki hiçbir şey için "ödeme yapmadığınız" anlamına gelmez . Hala soyutlama için ödeme yapıyorsunuz ve aynı zamanda C standart kütüphanesinin başlatılması ve dinamik çözünürlük printfişlevi (veya aslında putsherhangi bir format dizesine ihtiyacınız olmadığı için derleyici tarafından optimize edildi) hala başlık altında gerçekleşiyor.

Bu programı saf montajda yazacak olsaydınız, şöyle bir şey olurdu:

jmp start

msg db "Hello world\n"

start:
    mov rdi, 1
    mov rsi, offset msg
    mov rdx, 11
    mov rax, 1          ; write
    syscall
    xor rdi, rdi
    mov rax, 60         ; exit
    syscall

Bu da temel olarak yalnızca write sistem çağrısını çağırmakla ve ardından sistem çağrısıyla sonuçlanır exit. Şimdi , aynı şeyi başarmak için asgari olan bu olurdu.

Özetlemek

C çok daha çıplak kemiklidir ve sadece gerekli olan minimum değeri yapar, kullanıcıya tam kontrol sağlar, bu da istedikleri her şeyi tamamen optimize edebilir ve özelleştirebilir. İşlemciye bir kayıt defterine bir dize yüklemesini ve ardından bu dizeyi kullanmak için bir kütüphane işlevini çağırmasını söylersiniz. C ++ ise çok daha karmaşık ve soyuttur . Bu, karmaşık kod yazarken çok büyük bir avantaja sahiptir ve daha kolay yazılmasına ve daha insan dostu kodlara izin verir, ancak açıkçası bir bedeli vardır. Böyle durumlarda C ++ ile karşılaştırıldığında C ++ performansında her zaman bir dezavantaj olacaktır, çünkü C ++ bu temel görevleri yerine getirmek için gerekenden daha fazlasını sunar ve bu nedenle daha fazla ek yük getirir .

Ana sorunuza cevap :

Yediğim şeyler için para ödüyor muyum?

Bu özel durumda, evet . C ++ 'ın C'den daha fazlasını sunması gereken herhangi bir şeyden yararlanmıyorsunuz, ancak bunun nedeni C ++' ın size yardımcı olabileceği basit bir kod parçasında hiçbir şey olmaması: gerçekten C ++ 'a hiç ihtiyacınız yok.

Oh, ve sadece bir şey daha!

C ++ 'ın avantajları ilk bakışta belirgin görünmeyebilir, çünkü çok basit ve küçük bir program yazdınız, ancak biraz daha karmaşık bir örneğe bakın ve farkı görün (her iki program da aynı şeyi yapar):

C :

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}

int main(void) {
    int i, n, *arr;

    printf("How many integers do you want to input? ");
    scanf("%d", &n);

    arr = malloc(sizeof(int) * n);

    for (i = 0; i < n; i++) {
        printf("Index %d: ", i);
        scanf("%d", &arr[i]);
    }

    qsort(arr, n, sizeof(int), cmp)

    puts("Here are your numbers, ordered:");

    for (i = 0; i < n; i++)
        printf("%d\n", arr[i]);

    free(arr);

    return 0;
}

C ++ :

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(void) {
    int n;

    cout << "How many integers do you want to input? ";
    cin >> n;

    vector<int> vec(n);

    for (int i = 0; i < vec.size(); i++) {
        cout << "Index " << i << ": ";
        cin >> vec[i];
    }

    sort(vec.begin(), vec.end());

    cout << "Here are your numbers:" << endl;

    for (int item : vec)
        cout << item << endl;

    return 0;
}

Umarım burada ne demek istediğimi açıkça görebilirsiniz. Kullandığınız daha düşük bir seviyede bellek yönetmek zorunda nasıl C Ayrıca ihbar mallocve freeEndekslemede ve boyutları hakkında daha dikkatli olmak gerekir, nasıl ve giriş alarak ve baskı sırasında çok özel olması gerekli ne.

Başlamak için birkaç yanlış anlama var. Birincisi, C ++ programı gelmez bunlardan 22.000 (benim şapka bu sayıyı çekti ama ballpark yaklaşık var) daha gibi, 22 talimatlar sonuçlanabilir. Ayrıca, C kodu da 9 talimatla sonuçlanmaz. Bunlar sadece gördükleriniz.

C kodunun yaptığı, görmediğiniz bir çok şey yaptıktan sonra, CRT'den bir işlevi çağırır (genellikle paylaşılan lib olarak var olmak zorunda değildir ), sonra dönüş değerini kontrol etmez veya işlemez hatalar ve kefaletler. Derleyici ve hatta gerçekten çağırmaz optimizasyon ayarlarına bağlı olarak printfancak puts, hatta daha ilkel bir şey.
Aynı işlevi aynı şekilde çağırdıysanız, C ++ 'da aynı programı (bazı görünmez init işlevleri hariç) az çok yazmış olabilirsiniz. Veya, süper-doğru olmak istiyorsanız, aynı fonksiyonun önüne eklenir std::.

Karşılık gelen C ++ kodu gerçekte aynı şey değildir. Her <iostream>şey küçük programlar için muazzam bir yük ekleyen şişman çirkin bir domuz olduğu için iyi bilinmesine rağmen ("gerçek" bir programda gerçekten çok fazla fark etmiyorsunuz), biraz daha adil bir yorum, korkunç bir şey yapmasıdır. Görmediğiniz ve işe yarayan birçok şey . Farklı sayı biçimleri ve yerel ayarlar ve ne olursa olsun, arabellekleme ve uygun hata işleme de dahil olmak üzere hemen hemen her tür gelişmenin sihirli biçimlendirmesini içerir, ancak bunlarla sınırlı değildir. Hata yönetimi? Evet, tahmin edin, bir dizenin çıktısı gerçekten başarısız olabilir ve C programının aksine, C ++ programı bunu sessizce göz ardı etmez . Ne düşünüldüğündestd::ostreamkaputun altında, ve kimse farkında olmadan, aslında oldukça hafif. Akış sözdiziminden bir tutkuyla nefret ettiğim için kullandığım gibi değil. Ama yine de, ne yaptığını düşünürseniz oldukça harika.

Ama elbette, C ++ genel olarak C olabildiğince verimli değildir . Aynı şey değildir ve değildir çünkü verimli olarak olamaz yapıyor aynı şeyi. Başka bir şey yoksa, C ++ istisnalar (ve bunları oluşturmak, işlemek veya başarısız olmak için kod) üretir ve C'nin vermediği bazı garantiler verir. Yani, elbette, bir C ++ programının biraz daha büyük olması gerekiyor. Bununla birlikte, büyük resimde, bunun hiçbir şekilde önemi yoktur. Aksine, gerçek programlar için, C ++ 'ın nadiren daha iyi performans göstermediğini gördüm çünkü bir nedenden ötürü, daha uygun optimizasyonlar için borç veriyor gibi görünüyor. Bana özellikle nedenini sorma, bilmiyorum.

En iyisi için ateşle ve unut-umut-umut yerine doğru C kodunu yazmayı önemsiyorsanız (yani hataları kontrol edersiniz ve program hataların varlığında doğru davranırsa), fark marjinaldir, eğer varsa.

Bir hata ödüyorsun. 80'lerde, derleyiciler biçim dizelerini kontrol etmek için yeterince iyi olmadığında, operatör aşırı yüklemesi, io sırasında tip güvenliği benzetmesinin iyi bir yolu olarak görülüyordu. Bununla birlikte, banner özelliklerinin her biri başlangıçtan itibaren kötü veya kavramsal olarak iflas eder:

<İomanip>

C ++ akışının en iğrenç kısmı, bu biçimlendirme başlık kütüphanesinin varlığıdır. Durumsal ve çirkin ve hataya yatkın olmasının yanı sıra, biçimlendirmeyi akışa bağlar.

8 basamaklı sıfır dolu onaltılık işaretsiz int ve ardından bir boşluk ve ardından 3 ondalık basamaklı bir çift yazdırmak istediğinizi varsayalım. İle <cstdio>, özlü bir biçim dizesi okuyabilirsiniz. İle <ostream>, eski durumu kaydetmeniz, hizalamayı sağa ayarlamanız, dolgu karakterini ayarlamanız, dolgu genişliğini ayarlamanız, tabanı onaltılı olarak ayarlamanız, tamsayı çıkarmanız, kaydedilmiş durumu geri yüklemeniz (aksi takdirde tamsayı biçimlendirmeniz kayan biçimlendirmeyi kirletecektir), boşluk , gösterimi sabit olarak ayarlayın, hassasiyeti ayarlayın, çift ve yeni satırın çıktısını alın, ardından eski biçimlendirmeyi geri yükleyin.

// <cstdio>
std::printf( "%08x %.3lf\n", ival, fval );

// <ostream> & <iomanip>
std::ios old_fmt {nullptr};
old_fmt.copyfmt (std::cout);
std::cout << std::right << std::setfill('0') << std::setw(8) << std::hex << ival;
std::cout.copyfmt (old_fmt);
std::cout << " " << std::fixed << std::setprecision(3) << fval << "\n";
std::cout.copyfmt (old_fmt);

Operatör Aşırı Yüklemesi

<iostream> aşırı yüklenmenin nasıl kullanılamayacağının afiş çocuğu:

std::cout << 2 << 3 && 0 << 5;

Verim

std::coutbirkaç kez daha yavaştır printf(). Yaygın featurit ve sanal sevkiyat zahmetine girer.

İplik Güvenliği

Her ikisi de <cstdio> ve <iostream>her işlev çağrısı atomik olması ile parçacığı için güvenlidir. Ancak, printf()arama başına çok daha fazla şey yapılır. Aşağıdaki programı <cstdio>seçenekle çalıştırırsanız, yalnızca bir satır görürsünüz f. Çok <iostream>çekirdekli bir makinede kullanırsanız, muhtemelen başka bir şey görürsünüz.

// g++ -Wall -Wextra -Wpedantic -pthread -std=c++17 cout.test.cpp

#define USE_STREAM 1
#define REPS 50
#define THREADS 10

#include <thread>
#include <vector>

#if USE_STREAM
    #include <iostream>
#else
    #include <cstdio>
#endif

void task()
{
    for ( int i = 0; i < REPS; ++i )
#if USE_STREAM
        std::cout << std::hex << 15 << std::dec;
#else
        std::printf ( "%x", 15);
#endif

}

int main()
{
    auto threads = std::vector<std::thread> {};
    for ( int i = 0; i < THREADS; ++i )
        threads.emplace_back(task);

    for ( auto & t : threads )
        t.join();

#if USE_STREAM
        std::cout << "\n<iostream>\n";
#else
        std::printf ( "\n<cstdio>\n" );
#endif
}

Bu örneğe karşılık, çoğu insanın zaten birden fazla iş parçacığından tek bir dosya tanımlayıcıya asla yazmak için disiplin kullanmasıdır. Eh, bu durumda, bunu gözlemlemek gerekecek <iostream>yardımsever her bir kilit çekecek <<ve her >>. Oysa <cstdio>, sık sık kilitlemeyeceksiniz ve hatta kilitlememe seçeneğiniz de var.

<iostream> daha az tutarlı bir sonuç elde etmek için daha fazla kilit harcar.

Diğer tüm cevapların söylediklerine ek olarak , aynı şey olmadığı
gerçeği de var .std::endl'\n'

Bu maalesef yaygın bir yanlış anlamadır. std::endl"yeni satır" anlamına gelmez, "yeni satır
yazdır" anlamına gelir ve ardından akışı temizle . Kızarma ucuz değildir!

C örneğinize işlevsel olarak uygun olması için bir an için printfve arasındaki farkları tamamen göz ardı ederek, std::coutC ++ örneğiniz aşağıdaki gibi olmalıdır:

#include <iostream>

int main()
{
    std::cout << "Hello world\n";
    return 0;
}

Ve burada kızarmayı dahil ederseniz örneklerinizin nasıl olması gerektiğine dair bir örnek.

C

#include <stdio.h>

int main()
{
    printf("Hello world\n");
    fflush(stdout);
    return 0;
}

C ++

#include <iostream>

int main()
{
    std::cout << "Hello world\n";
    std::cout << std::flush;
    return 0;
}

Kodu karşılaştırırken, beğen gibi karşılaştırdığınıza ve kodunuzun ne yaptığının sonuçlarını anladığınıza dikkat etmelisiniz. Bazen en basit örnekler bile bazı insanların düşündüğünden daha karmaşıktır.

Mevcut teknik cevaplar doğru olsa da, sorunun nihayetinde bu yanlış anlamadan kaynaklandığını düşünüyorum:

C ++ 'da ne yediğinizi ödediğiniz ünlüdür.

Bu sadece C ++ topluluğundan pazarlama konuşması. (Adil olmak gerekirse, her dil topluluğunda pazarlama konuşması vardır.) Bu ciddi bir şekilde güvenebileceğiniz somut bir şey anlamına gelmez.

"Kullandığınız kadar ödersiniz", bir C ++ özelliğinin yalnızca bu özelliği kullanıyorsanız ek yükü olduğu anlamına gelir. Ancak "bir özellik" tanımı sınırsız bir şekilde değildir. Çoğunlukla, birden fazla yönü olan özellikleri etkinleştirirsiniz ve yalnızca bu özelliklerin bir alt kümesine ihtiyacınız olsa da, uygulamanın özelliği kısmen getirmesi genellikle pratik veya mümkün değildir.

Genel olarak, birçok dil (tartışmasız hepsi olmasa da), farklı derecelerde başarı ile verimli olmaya çalışır. C ++ ölçeğin bir yerinde, ancak tasarımında bu hedefte mükemmel bir şekilde başarılı olmasını sağlayacak özel veya büyülü bir şey yok.

C ++ 'da Giriş / Çıkış işlevleri zarif bir şekilde yazılmıştır ve kullanımı kolay olacak şekilde tasarlanmıştır. Birçok açıdan, C ++ 'da nesne yönelimli özellikler için bir vitrindir.

Ama aslında biraz performanstan vazgeçiyorsunuz, ancak işlevleri daha düşük bir düzeyde işlemek için işletim sisteminizin harcadığı zamana kıyasla bu önemsiz.

C ++ standardının bir parçası oldukları için C stili işlevlerine her zaman geri dönebilir veya belki de taşınabilirliği tamamen bırakabilir ve işletim sisteminize doğrudan çağrıları kullanabilirsiniz.

Diğer cevaplarda gördüğünüz gibi, genel kütüphanelere bağlandığınızda ve karmaşık kurucuları çağırdığınızda ödeme yaparsınız. Burada özel bir soru yok, daha fazla sancı. Bazı gerçek dünya yönlerine dikkat çekeceğim:

1. Barne, verimliliğin C ++ yerine C'de kalmanın bir nedeni olmasına asla izin vermeyecek temel bir tasarım ilkesine sahipti. Bununla birlikte, bu verimlilikleri elde etmek için dikkatli olunması gerekir ve her zaman işe yarayan ancak C spesifikasyonu içinde 'teknik olarak' olmayan ara sıra verimlilikler vardır. Örneğin, bit alanlarının düzeni gerçekten belirtilmedi.

2. Ostream'e bakmayı deneyin. Aman tanrım şişti! Orada bir uçuş simülatörü bulmak beni şaşırtmaz. Stdlib'in printf () bile genellikle yaklaşık 50K çalışır. Bunlar tembel programcılar değil: printf boyutunun yarısı çoğu insanın asla kullanmadığı dolaylı hassasiyet argümanlarıyla ilgiliydi. Hemen hemen her gerçekten kısıtlanmış işlemci kütüphanesi printf yerine kendi çıkış kodunu oluşturur.

3. Boyuttaki artış genellikle daha kapsayıcı ve esnek bir deneyim sağlar. Bir benzetme olarak, bir satış makinesi birkaç bozuk para için bir fincan kahve benzeri madde satacak ve tüm işlem bir dakikadan az sürüyor. İyi bir restorana girmek, bir masa ayarı, oturmak, sipariş vermek, beklemek, güzel bir fincan almak, bir fatura almak, form seçiminizi ödemek, bir ipucu eklemek ve çıkışta iyi bir gün dilemek. Onun farklı bir deneyim ve karmaşık bir yemek için arkadaşlarınızla bırakarak daha uygun.

4. İnsanlar hala ANSI C yazıyor, nadiren K&R C. Deneyimlerim, sürüklenenleri sınırlamak için birkaç yapılandırma ince ayarı kullanarak her zaman bir C ++ derleyicisi ile derliyoruz. ; daha akıllı alan paketleme ve bellek düzeni için bazı iyi argümanlar olmuştur. IMHO Bence herhangi bir dil tasarımı , Python'un Zen'i gibi bir hedefler listesiyle başlamalıdır .

Eğlenceli bir tartışma oldu. Neden sihirli, küçük, basit, zarif, eksiksiz ve esnek kütüphanelere sahip olamayacağınızı soruyorsunuz?

Cevabı yok. Bir cevap olmayacak. Cevap bu.