Boş sonlandırılmış dizelerin mantığı nedir?

C ve C ++ 'ı sevdiğim kadarıyla, boş sonlandırılmış dizelerin seçiminde başımı çizemiyorum:

• Önceden eklenmiş uzunluk (yani Pascal) dizeleri C'den önce vardı
• Uzunluk ön ekli dizeler, sabit süre uzunluğu aramasına izin vererek birkaç algoritmayı daha hızlı hale getirir.
• Uzunluk ön ekli dizeler, arabellek taşması hatalarına neden olmayı zorlaştırır.
• 32 bitlik bir makinede bile, dizenin kullanılabilir belleğin boyutu olmasına izin verirseniz, uzunluk ön ekli dize, boş bir sonlandırılmış dizeden yalnızca üç bayt daha geniştir. 16 bitlik makinelerde bu tek bir bayttır. 64 bitlik makinelerde, 4GB makul bir dize uzunluğu sınırıdır, ancak makine sözcüğünün boyutuna genişletmek isteseniz bile, 64 bitlik makineler genellikle fazladan yedi baytlık null argüman yapan geniş bir belleğe sahiptir. Orijinal C standardının inanılmaz derecede zayıf makineler için (bellek açısından) yazıldığını biliyorum, ancak verimlilik argümanı beni burada satmıyor.
• Diğer tüm diller (ör. Perl, Pascal, Python, Java, C #, vb.) Uzunluk ön ekli dizeler kullanır. Bu diller genellikle string manipülasyon kriterlerinde C'yi geçerler çünkü stringlerle daha verimlidirler.
• C ++ bunu std::basic_stringşablonla biraz düzeltti , ancak boş sonlandırılmış dizeler bekleyen düz karakter dizileri hala yaygın. Bu aynı zamanda kusurludur, çünkü yığın tahsisi gerektirir.
• Boş sonlandırılmış dizeler, dizede bulunmayan bir karakter (yani null) ayırmalıdır; uzunluk ön ekli dizeler katıştırılmış boş değerler içerebilir.

Bunların birçoğu C'den daha yakın bir zamanda ortaya çıktı, bu yüzden C'nin onları bilmemesi mantıklı olurdu. Ancak, birkaç kişi C gelmeden çok açıktı. Açıkça üstün uzunluklu önek yerine null sonlandırılmış dizeler neden seçilsin ki?

EDIT : Bazıları yukarıdaki verimlilik noktamda gerçekler istediğinden (ve zaten sağladığımları beğenmediğinden), birkaç şeyden kaynaklanıyor:

• Boş sonlandırılmış dizeler kullanılarak yapılan concat, O (n + m) zaman karmaşıklığı gerektirir. Uzunluk ön eki genellikle yalnızca O (m) gerektirir.
• Boş sonlandırılmış dizeler kullanan uzunluk O (n) zaman karmaşıklığı gerektirir. Uzunluk ön eki O (1) 'dir.
• Uzunluk ve concat açık ara en yaygın dize işlemleri. Boş sonlandırılmış dizelerin daha verimli olabileceği birkaç durum vardır, ancak bunlar çok daha az sıklıkla görülür.

Aşağıdaki yanıtlardan, boş sonlandırılmış dizelerin daha verimli olduğu bazı durumlar şunlardır:

• Bir dizenin başlangıcını kesmeniz ve bir yönteme geçirmeniz gerektiğinde. Orijinal dizeyi yok etmenize izin verilse bile, bunu uzunluk önekiyle sabit bir zamanda yapamazsınız, çünkü uzunluk önekinin hizalama kurallarına uyması gerekir.
• Bazı karakterleri karakter dizisine göre döngüye soktuğunuz durumlarda, bir CPU kaydını kaydedebilirsiniz. Bunun yalnızca dizeyi dinamik olarak ayırmamış olmanız durumunda işe yaradığını unutmayın (Çünkü o zaman serbest bırakmak zorunda kalacaksınız, çünkü malloc ve arkadaşlardan aldığınız işaretçiyi tutmak için kaydettiğiniz CPU kaydını kullanmanız gerekir).

Yukarıdakilerin hiçbiri uzunluk ve akrabalık kadar yaygın değildir.

Aşağıdaki cevaplarda bir iddia daha var:

• Dizenin sonunu kesmelisin

ancak bu yanlıştır - boş sonlandırılmış ve uzunluk ön ekli dizeler için aynı süre geçerlidir. (Boş sonlandırılmış dizeler, yeni sonun olmasını istediğiniz yere boş bir değer yapıştırır; uzunluk önekleri yalnızca önekten çıkarılır.)

Gönderen at ağzına

Hiçbir BCPL, B veya C, karakter verilerini dilde güçlü bir şekilde desteklemez; her biri dizelere tamsayı vektörleri gibi davranır ve genel kuralları birkaç kuralla tamamlar. BCPL ve B'de bir dize değişmez değeri, dizeye karakterlerle başlatılan ve hücrelere paketlenmiş statik bir alanın adresini gösterir. BCPL'de, ilk paketlenmiş bayt dizede karakter sayısını içerir; B'de sayım yoktur ve dizeler B'nin yazdığı özel bir karakterle sonlandırılır *e. Bu değişiklik, sayının 8 veya 9 bitlik bir yuvada tutulmasının neden olduğu bir dizenin uzunluğundaki sınırlamadan kaçınmak için kısmen yapıldı ve kısmen sayımın tutulması, deneyimlerimize göre, bir sonlandırıcı kullanmaktan daha az uygun görünüyordu.

_{Dennis M Ritchie, C Dilinin Gelişimi}

C'nin dilin bir parçası olarak bir dizesi yoktur. C'deki bir 'dize' sadece karakter için bir göstergedir. Belki de yanlış soruyu soruyorsun.

"Bir dize türünü dışarıda bırakmanın mantığı nedir" daha alakalı olabilir. Bunun için C'nin nesneye yönelik bir dil olmadığını ve sadece temel değer türlerine sahip olduğunu belirtmek isterim. Dize, bir şekilde diğer türlerin değerlerini birleştirerek uygulanması gereken daha üst düzey bir kavramdır. C daha düşük bir soyutlama seviyesindedir.

aşağıdaki şiddetli fırtına ışığında:

Ben sadece bu aptalca ya da kötü bir soru olduğunu söylemeye çalışmıyorum ya da dizeleri temsil C yolu en iyi seçim olduğunu belirtmek istiyorum. C bir bayt diziden bir veri türü olarak bir dize ayırt etmek için bir mekanizma yok aslında dikkate alırsanız soru daha kısa sürede koymak olacağını açıklamaya çalışıyorum. Günümüz bilgisayarlarının işlem ve bellek gücü ışığında bu en iyi seçim mi? Muhtemelen değil. Ama gez her zaman 20/20 ve tüm bunlar :)

Soru bir Length Prefixed Strings (LPS)vs sorusu olarak sorulur zero terminated strings (SZ), ancak çoğunlukla uzunluk ön ekli dizelerin faydalarını ortaya çıkarır. Bu ezici görünebilir, ancak dürüst olmak gerekirse, LPS'nin dezavantajlarını ve SZ'nin avantajlarını da düşünmeliyiz.

Anladığım kadarıyla, soru "Sıfır Sonlandırılmış Dizelerin avantajları nelerdir?" Sorusunun taraflı bir yolu olarak bile anlaşılabilir.

Sıfır Sonlandırılmış Dizelerin Avantajları (anlıyorum):

• çok basit, dilde yeni kavramlar tanıtmaya gerek yok, char dizileri / char işaretçiler yapabilirsiniz.
• Çekirdek dil, çift tırnaklar arasındaki bir şeyi bir sürü karaktere (gerçekten bir demet bayt) dönüştürmek için minimal sözdizimi şekeri içerir. Bazı durumlarda, metinle tamamen ilgisiz olan şeyleri başlatmak için kullanılabilir. Örneğin, xpm görüntü dosyası biçimi, dize olarak kodlanan görüntü verilerini içeren geçerli bir C kaynağıdır.
• bu arada, yapabilirsiniz derleyici sadece ayrıca edebi sonunda bir tane daha ekleyecek bir dize bir sıfır koyun: "this\0is\0valid\0C". Bu bir dize mi? veya dört tel mi? Ya da bir demet bayt ...
• düz uygulama, gizli dolaylı, gizli tamsayı yok.
• hiçbir gizli bellek tahsisi söz konusu değildir (iyi, strdup gibi bazı standart dışı işlevler tahsis gerçekleştirir, ancak bu çoğunlukla bir sorun kaynağıdır).
• küçük veya büyük donanım için belirli bir sorun yok (8 bit mikrodenetleyicilerde 32 bit önek uzunluğunu yönetme yükünü veya dize boyutunu 256 bayttan daha azıyla sınırlama sınırlarını hayal edin, bu aslında Turbo Pascal eons ile ilgili bir sorunumdu).
• dize manipülasyonunun uygulanması sadece bir avuç çok basit kütüphane fonksiyonudur
• dizelerin ana kullanımı için verimli: bilinen bir başlangıçtan itibaren sıralı olarak okunan sabit metin (çoğunlukla kullanıcıya mesajlar).
• sonlandırma sıfır bile zorunlu değildir, bir dizi bayt gibi karakterleri işlemek için gerekli tüm araçlar mevcuttur. C'de dizi başlatma işlemini gerçekleştirirken, NUL sonlandırıcıdan bile kaçınabilirsiniz. Sadece doğru boyutu ayarlayın. char a[3] = "foo";geçerli C'dir (C ++ değil) ve a'ya son sıfır koymaz.
• stdin, stdout gibi içsel uzunluğu olmayan "dosyalar" dahil olmak üzere "her şey dosyadır" unix bakış açısıyla uyumludur. Açık okuma ve yazma ilkellerinin çok düşük bir seviyede uygulandığını unutmamalısınız. Bunlar kütüphane çağrıları değil, sistem çağrılarıdır. İkili veya metin dosyaları için de aynı API kullanılır. Dosya okuma ilkeleri bir arabellek adresi ve bir boyut alır ve yeni boyutu döndürür. Ve yazmak için arabellek olarak dizeleri kullanabilirsiniz. Başka tür bir dize temsili kullanmak, basit bir dizgeyi çıktı olarak tampon olarak kolayca kullanamayacağınız anlamına gelir veya bunu yayınlarken çok garip bir davranışa sahip olmanız gerekir char*. Yani dizenin adresini döndürmek yerine gerçek verileri döndürmek.
• bir dosyadan okunan metin verilerini, arabellek yararsız bir kopyası olmadan, değiştirmek için çok kolay, sadece doğru yerlere sıfır ekleyin (çift tırnaklı dizeler günümüzde genellikle değiştirilemez verilerde tutulan sabit diziler olduğundan, gerçekten modern C ile değil kesim).
• hangi boyutta olursa olsun bazı int değerlerinin eklenmesi, hizalama sorunları anlamına gelir. Başlangıç ​​uzunluğu hizalanmalıdır, ancak karakter verileri için bunu yapmak için hiçbir neden yoktur (ve yine, dizelerin hizalanmasını zorlamak, bir demet bayt olarak tedavi edilirken sorun yaratacaktır).
• uzunluk, sabit değişmez dizeler için derleme zamanında bilinir (sizeof). Öyleyse neden gerçek verilerden önce bellekte saklamak istesin ki?
• C (neredeyse) herkes gibi yapıyorsa, dizeler karakter dizisi olarak görülür. Dizi uzunluğu C tarafından yönetilmediğinden, mantıksal uzunluk da dizeler için yönetilmez. Tek şaşırtıcı olan şey, 0 öğenin sonuna eklenmiş olmasıdır, ancak bu, çift tırnak arasına bir dize yazarken temel dil düzeyindedir. Kullanıcılar, uzunluğu geçen dize düzenleme işlevlerini mükemmel bir şekilde çağırabilir veya bunun yerine düz memcopy kullanabilirler. SZ sadece bir tesistir. Diğer birçok dilde dizi uzunluğu yönetilir, dizeler için aynı olan mantıklıdır.
• yine de modern zamanlarda 1 bayt karakter setleri yeterli değildir ve genellikle karakter sayısının bayt sayısından çok farklı olduğu kodlanmış unicode dizelerle uğraşmak zorunda kalırsınız. Bu, kullanıcıların büyük olasılıkla "yalnızca boyuttan" daha fazlasını ve aynı zamanda diğer bilgileri isteyeceğini ima eder. Uzunluğu korumak, bu diğer faydalı bilgilerle ilgili hiçbir şey kullanmaz (özellikle saklamak için doğal bir yer yoktur).

Bununla birlikte, standart C dizelerinin gerçekten verimsiz olduğu nadir durumlarda şikayet etmeye gerek yoktur. Lib'ler mevcuttur. Bu eğilimi izlesem, standart C'nin herhangi bir normal ifade destek işlevi içermediğinden şikayet etmeliyim ... ama gerçekten herkes bunun gerçek bir sorun olmadığını biliyor, çünkü bu amaç için kullanılabilir kütüphaneler var. Dize düzenleme verimliliği istendiğinde neden bstring gibi bir kitaplık kullanılmıyor ? Ya da C ++ dizeleri?

EDIT : Geçenlerde D dizeleri bir göz vardı . Seçilen çözümün ne boyut öneki ne de sıfır sonlandırma olduğunu görmek yeterince ilginçtir. C'de olduğu gibi, çift tırnak içine alınmış değişmez dizgiler değişmez karakter dizileri için kısa eldir ve dil aynı zamanda (değişmez karakter dizisi) anlamına gelen bir dize anahtar sözcüğüne sahiptir.

Ancak D dizileri C dizilerinden çok daha zengindir. Statik dizilerde, çalışma zamanında uzunluk bilinmektedir, bu nedenle uzunluğun depolanmasına gerek yoktur. Derleyici derleme zamanında vardır. Dinamik diziler söz konusu olduğunda uzunluk mevcuttur ancak D dokümantasyonu nerede tutulduğunu belirtmez. Tüm bildiğimiz için, derleyici bunu bir kayıtta veya karakter verilerinden uzakta saklanan bazı değişkenlerde tutmayı seçebilir.

Normal karakter dizilerinde veya değişmez dizgilerde son sıfır yoktur, bu nedenle programcı D'den biraz C işlevi çağırmak istiyorsa kendisini koymalıdır. Özel dizgi dizilerinde D derleyicisi hala Her bir dizenin sonu (C işlevlerini çağırmayı kolaylaştırmak için C dizelerine kolay yayın yapılmasına izin vermek için?), ancak bu sıfır dizenin bir parçası değildir (D dizgi boyutunda saymaz).

Beni biraz hayal kırıklığına uğratan tek şey, dizelerin utf-8 olması gerekiyordu, ancak uzunluk çok baytlık karakterleri kullanırken bile hala bir dizi bayt (en azından derleyici gdc'de doğrudur) döndürüyor. Bir derleyici hatası mı yoksa amaç için mi olduğu belli değil. (Tamam, muhtemelen ne olduğunu öğrendim. D derleyicinize kaynağınızı utf-8 kullanmak için başlangıçta aptal bayt sırası işareti koymak zorundasınız. Aptal yazıyorum, özellikle editör olmadığını biliyorum, özellikle UTF- ASCII uyumlu olması gerekir).

Bence, tarihsel nedenleri var ve bunu wikipedia'da buldu :

C (ve türetildiği diller) geliştirilirken, bellek son derece sınırlıydı, bu nedenle bir dizenin uzunluğunu saklamak için sadece bir bayt ek yükü kullanmak çekici idi. O zamanlar genellikle "Pascal dizesi" olarak adlandırılan tek popüler alternatif (BASIC'in ilk sürümlerinde de kullanılsa da) dizenin uzunluğunu depolamak için önde gelen bir bayt kullandı. Bu, dizginin NUL içermesini sağlar ve uzunluğu bulmak için yalnızca bir bellek erişimine (O (1) (sabit) zaman) ihtiyaç duyulur. Ancak bir bayt uzunluğu 255 ile sınırlar. Bu uzunluk sınırlaması C dizesiyle ilgili problemlerden çok daha kısıtlayıcıydı, bu nedenle C dizisi genel olarak kazandı.

Calavera olduğu doğru , ama insanlar onun noktası olsun görünmemektedir gibi, bazı kod örnekler sunacağız.

İlk olarak, C'nin ne olduğunu düşünelim: tüm kodların makine diline oldukça doğrudan bir çevirisi olan basit bir dil. Tüm türler kayıtlara ve yığına sığar ve çalıştırmak için bir işletim sistemi veya büyük bir çalışma zamanı kütüphanesi gerektirmez, çünkü bu şeyleri yazmak için tasarlanmıştır (orada dikkate alınarak son derece uygun bir görev) bu gün için muhtemel bir rakip bile değil).

C'nin veya stringgibi bir türü olsaydı, bir kayıt defterine veya yığına sığmayan ve herhangi bir şekilde ele alınması için bellek tahsisinin (tüm destekleyici altyapısı ile) yapılmasını gerektiren bir tür olurdu. Hepsi C'nin temel prensiplerine aykırıdır.intchar

Yani, C'deki bir dize:

char s*;

Öyleyse, bunun uzunluğunda önek olduğunu varsayalım. İki dizeyi birleştirmek için kodu yazalım:

char* concat(char* s1, char* s2)
{
    /* What? What is the type of the length of the string? */
    int l1 = *(int*) s1;
    /* How much? How much must I skip? */
    char *s1s = s1 + sizeof(int);
    int l2 = *(int*) s2;
    char *s2s = s2 + sizeof(int);
    int l3 = l1 + l2;
    char *s3 = (char*) malloc(l3 + sizeof(int));
    char *s3s = s3 + sizeof(int);
    memcpy(s3s, s1s, l1);
    memcpy(s3s + l1, s2s, l2);
    *(int*) s3 = l3;
    return s3;
}

Başka bir alternatif, bir dizeyi tanımlamak için bir yapı kullanmaktır:

struct {
  int len; /* cannot be left implementation-defined */
  char* buf;
}

Bu noktada, tüm dize manipülasyonu iki tahsisat gerektirir, bu da pratikte, herhangi bir işlem yapmak için bir kütüphaneden geçeceğiniz anlamına gelir.

Garip olan ... gibi yapılar yapmak C var! Bunlar, günlük kullanımınız için kullanıcı yönetimine yönelik mesajları görüntülemek için kullanılmaz.

İşte Calavera'nın yaptığı şey: C'de dize türü yok . Onunla herhangi bir şey yapmak için, bir işaretçi alıp iki farklı türe işaretçi olarak kodunu çözmeniz gerekir ve sonra bir dizenin boyutunun ne olduğu çok alakalı olur ve "uygulama tanımlı" olarak bırakılamaz.

Şimdi, C olabilir yine de hafıza ve kolu mem(kitaplıktaki işlevleri <string.h>! Bile,) sen pointer ve boyutta bir çifti olarak sap belleğine gereken tüm takım sağlarlar. Sözde "dizeleri" metin terminalleri için amaçlanan bir işletim sistemi yazımı bağlamında gösteren mesajlar: C sadece bir amaç için oluşturulmuştur. Ve bunun için boş sonlandırma yeterlidir.

Açıkçası performans ve güvenlik için, tekrar tekrar performans yapmak strlenveya üzerinde eşdeğer olmak yerine, bir dizenin uzunluğunu korumak isteyeceksiniz . Bununla birlikte, uzunluğu dize içeriğinden hemen önce sabit bir yerde saklamak inanılmaz derecede kötü bir tasarımdır. Jörgen'in Sanjit'in cevabındaki yorumlarda işaret ettiği gibi, bir dizginin kuyruğuna bir dize gibi davranmayı engeller, bu da örneğin yeni bellek ayırmadan (ve hata ve hata işleme olasılığına maruz kalmadan) birçok yaygın işlemi imkansız path_to_filenameveya filename_to_extensionimkansız hale getirir. . Ve sonra elbette kimse dize uzunluğu alanının kaç bayt işgal etmesi gerektiği konusunda anlaşamaz (çok sayıda kötü "Pascal dizesi"

C'nin, programlayıcının uzunluğun daha esnek / güçlü olup olmadığını / nerede / nasıl saklanacağını seçmesine izin verme tasarımı. Ama elbette programcı akıllı olmalı. C, çökme, durma noktasına gelme veya düşmanlarınıza kök salma programları ile aptallığı cezalandırır.

Tembellik, herhangi bir dilin, özellikle montajın bir adım üzerinde olan C'nin montaj bağırsaklarını göz önünde bulundurarak tutumluluk ve taşınabilirliği kaydedin (böylece bir çok montaj eski kodunu miras alır). Bu ASCII günlerinde null karakterlerin işe yaramayacağını kabul edersiniz, (ve muhtemelen bir EOF kontrol karakterleri kadar iyi).

görelim pseudo code

function readString(string) // 1 parameter: 1 register or 1 stact entries
    pointer=addressOf(string) 
    while(string[pointer]!=CONTROL_CHAR) do
        read(string[pointer])
        increment pointer

toplam 1 kayıt kullanımı

vaka 2

 function readString(length,string) // 2 parameters: 2 register used or 2 stack entries
     pointer=addressOf(string) 
     while(length>0) do 
         read(string[pointer])
         increment pointer
         decrement length

toplam 2 kayıt kullanıldı

Bu o zaman dar görüşlü görünebilir, ancak kod ve kayıttaki tutumluluğu göz önünde bulundurarak (o zaman PREMIUM idi, bildiğiniz zaman, delikli kart kullanıyorlar). Böylece daha hızlı olmak (işlemci hızı kHz olarak hesaplanabiliyorsa), bu "Hack" çok daha iyi ve taşınabilirdi.

Tartışma uğruna 2 ortak dize işlemi uygulayacağım

stringLength(string)
     pointer=addressOf(string)
     while(string[pointer]!=CONTROL_CHAR) do
         increment pointer
     return pointer-addressOf(string)

karmaşıklık O (n), burada çoğu durumda PASCAL dizesi O (1) 'dir, çünkü ipin uzunluğu ip yapısına eklenmiştir (bu aynı zamanda bu işlemin daha erken bir aşamada gerçekleştirilmesi gerektiği anlamına gelir).

concatString(string1,string2)
     length1=stringLength(string1)
     length2=stringLength(string2)
     string3=allocate(string1+string2)
     pointer1=addressOf(string1)
     pointer3=addressOf(string3)
     while(string1[pointer1]!=CONTROL_CHAR) do
         string3[pointer3]=string1[pointer1]
         increment pointer3
         increment pointer1
     pointer2=addressOf(string2)
     while(string2[pointer2]!=CONTROL_CHAR) do
         string3[pointer3]=string2[pointer2]
         increment pointer3
         increment pointer1
     return string3

karmaşıklığı O (n) ve dize uzunluğunu eklemek işlemin karmaşıklığını değiştirmezken, 3 kat daha az zaman alacağını itiraf ediyorum.

Diğer bir yandan, PASCAL dizesini kullanırsanız, kayıt uzunluğunu ve bit-endianitesini hesaba katmak için API'nizi yeniden tasarlamanız gerekir; PASCAL dizesi, uzunluk 1 bayt (8 bit) içinde saklandığı için 255 char (0xFF) iyi bilinen sınırlamasını aldı. ) ve daha uzun bir dize (16bits-> herhangi bir şey) istediğiniz kodun bir katmanındaki mimariyi hesaba katmanız gerekir, bu da daha uzun dize istiyorsanız çoğu durumda uyumsuz dize API'leri anlamına gelir.

Misal:

Bir dosya, 8 bitlik bir bilgisayarda önceden dize api ile yazılmış ve daha sonra 32 bitlik bir bilgisayar söylemek okunması gerekir, tembel program ne 4bayt dize uzunluğu olduğunu düşünüyor ne o kadar bellek ayırmak o kadar bayt okumaya çalışın. Başka bir durum, bir x86 (büyük endian) üzerine okunan PPC 32 bayt dizesi (küçük endian) olacaktır, elbette birinin diğeri tarafından yazıldığını bilmiyorsanız sorun olacaktır. 1 bayt uzunluğu (0x00000001), 1 bayt dizesini okumak için 16 MB olan 16777216 (0x0100000) olur. Tabii ki insanların tek bir standart üzerinde anlaşması gerektiğini söyleyebilirsin, ama 16 bitlik unicode bile çok az ve büyük bir endianiteye sahipti.

Tabii ki C'nin de sorunları olurdu ama burada ortaya çıkan sorunlardan çok az etkilenecekti.

Birçok yönden, C ilkeldi. Ve çok sevdim.

Montaj dilinin üzerinde bir adımdı ve size yazması ve bakımı çok daha kolay bir dille neredeyse aynı performansı veriyor.

Boş sonlandırıcı basittir ve dil tarafından özel bir destek gerektirmez.

Geriye dönüp baktığımda, o kadar uygun görünmüyor. Ama 80'lerde montaj dilini kullandım ve o zaman çok uygun görünüyordu. Sadece yazılımın sürekli geliştiğini ve platformların ve araçların sürekli daha karmaşıklaştığını düşünüyorum.

C'nin uygulandığı bir an için, uzunluklarına göre önek ekleyerek Pascal yolunu dizeleri varsayarsak: 7 karakter uzunluğunda bir dize, 3 karakterlik bir dize ile aynı VERİ TİPİ midir? Cevabınız evet ise, derleyiciyi ikincisine atadığımda derleyici ne tür bir kod üretmelidir? Dize kesilmeli veya otomatik olarak yeniden boyutlandırılmalı mı? Yeniden boyutlandırılırsa, bu işlem ipliğin güvenli olmasını sağlayacak bir kilitle mi korunmalıdır? C yaklaşımı tarafı tüm bu meselelere adım attı, ya da değil :)

Her nasılsa, C'de uzunluk ön ekli dizeler için derleyici desteği olmadığı anlamına gelen soruyu anladım. Aşağıdaki örnek, en azından dize uzunluklarının derleme zamanında sayıldığı kendi C dize kitaplığınızı başlatabileceğinizi gösterir:

#define PREFIX_STR(s) ((prefix_str_t){ sizeof(s)-1, (s) })

typedef struct { int n; char * p; } prefix_str_t;

int main() {
    prefix_str_t string1, string2;

    string1 = PREFIX_STR("Hello!");
    string2 = PREFIX_STR("Allows \0 chars (even if printf directly doesn't)");

    printf("%d %s\n", string1.n, string1.p); /* prints: "6 Hello!" */
    printf("%d %s\n", string2.n, string2.p); /* prints: "48 Allows " */

    return 0;
}

Bununla birlikte, bu dize işaretçisini ne zaman serbest bırakacağınıza ve statik olarak ne zaman tahsis edildiğine dikkat etmeniz gerektiğinden, hiçbir sorunla karşılaşmayacaktır (gerçek) char dizi) .

Düzenleme: Soruya daha doğrudan bir cevap olarak, benim görüşüm bu C hem de kullanılabilir bir dize uzunluğu (derleme zaman sabiti olarak) sahip destek olabilir yolu, ama yine de kullanmak istiyorsanız bellek ek yük ile sadece işaretçiler ve sıfır sonlandırma.

Tabii ki, sıfır uçlu dizelerle çalışmak önerilen uygulama gibiydi, çünkü standart kütüphane genel olarak dize uzunluklarını argüman olarak almaz ve uzunluğu ayıklamak char * s = "abc"örneğimin gösterdiği gibi basit bir kod değildir .

"32 bitlik bir makinede bile, dizenin kullanılabilir belleğin boyutu olmasına izin verirseniz, uzunluğunda önek dizesi boş bir sonlandırılmış dizgiden yalnızca üç bayt daha geniş olur."

İlk olarak, kısa dizeler için fazladan 3 bayt ek yük olabilir. Özellikle, sıfır uzunluklu bir dize şimdi 4 kat daha fazla bellek almaktadır. Bazılarımız 64 bit makineler kullanıyoruz, bu yüzden sıfır uzunluklu bir dize saklamak için 8 bayta ihtiyacımız var veya dize biçimi platformun desteklediği en uzun dizelerle baş edemiyor.

Ele alınması gereken uyum sorunları da olabilir. "Solo \ 0second \ 0 \ 0four \ 0five \ 0 \ 0seventh" gibi 7 dize içeren bir bellek bloğum olduğunu varsayalım. İkinci dize ofset 5'te başlar. Donanım, 32-bit tam sayıların 4'ün katları olan bir adrese hizalanmasını gerektirebilir, bu nedenle dolgu ekleyerek ek yükü daha da artırabilirsiniz. C gösterimi, kıyaslamada çok bellek tasarrufludur. (Bellek verimliliği iyidir; örneğin önbellek performansına yardımcı olur.)

Boş sonlandırma, hızlı işaretçi tabanlı işlemlere izin verir.

Henüz belirtilmeyen bir nokta: C tasarlandığında, bir 'char' sekiz bit olmayan birçok makine vardı (bugün bile olmayan DSP platformları var). Dizelerin uzunluk ön ekine sahip olacağına karar verirse, kaç tane karakter uzunluğunda önek kullanılmalıdır? İkisini kullanmak, 8 bit karakterli ve 32 bit adresleme alanına sahip makineler için dize uzunluğu üzerinde yapay bir sınır getirirken, 16 bit karakterli ve 16 bit adresleme alanına sahip makinelerde yer harcar.

Eğer biri rasgele uzunluktaki dizelerin verimli bir şekilde saklanmasına izin vermek istiyorsa ve 'char' her zaman 8 bit olsaydı, biri hız ve kod boyutunda bir miktar masraf için - bir düzen tanımlayabilirdi. N, N / 2 bayt uzunluğundadır, tek bir N değeri ile ön eklenmiş bir dize ve çift M değeri (geriye doğru okuma) ((N-1) + M * char_max) / 2 vb. Olabilir ve bir dizeyi tutmak için belirli bir miktarda alan sunma iddiasında, o alandan önce maksimum uzunluğu işlemek için yeterli bayt bulunmalıdır. Bununla birlikte, 'char' ın her zaman 8 bit olmadığı gerçeği, böyle bir şemayı karmaşık hale getirecektir, çünkü bir dizenin uzunluğunu tutmak için gereken 'char' sayısı CPU mimarisine bağlı olarak değişecektir.

C'yi çevreleyen birçok tasarım kararı, başlangıçta uygulandığında, parametre geçişinin biraz pahalı olmasından kaynaklanmaktadır. Örn.

void add_element_to_next(arr, offset)
  char[] arr;
  int offset;
{
  arr[offset] += arr[offset+1];
}

char array[40];

void test()
{
  for (i=0; i<39; i++)
    add_element_to_next(array, i);
}

karşı

void add_element_to_next(ptr)
  char *p;
{
  p[0]+=p[1];
}

char array[40];

void test()
{
  int i;
  for (i=0; i<39; i++)
    add_element_to_next(arr+i);
}

ikincisi, iki yerine sadece bir parametrenin geçirilmesini gerektirdiğinden, biraz daha ucuz olurdu (ve dolayısıyla tercih edilir). Eğer çağrılan yöntemin dizinin ya da içindeki dizinin temel adresini bilmesine gerek yoksa, ikisini birleştiren tek bir işaretçiyi geçmek değerleri ayrı ayrı iletmekten daha ucuz olacaktır.

C'nin dize uzunluklarını kodlayabilmesinin birçok makul yolu olsa da, o zamana kadar icat edilen yaklaşımlar, dizenin temel adresini kabul etmek için bir dizenin parçası ile çalışabilmesi gereken tüm gerekli işlevlere sahip olacaktı ve istenen indeksi iki ayrı parametre olarak gösterir. Sıfır baytlı sonlandırma kullanılması, bu gereksinimin ortadan kaldırılmasını mümkün kıldı. Her ne kadar günümüzdeki makinelerle diğer yaklaşımlar daha iyi olsa da (modern derleyiciler genellikle kayıtları kayıt parametrelerine geçirir ve memcpy strcpy () - eşdeğerlerinin yapamayacağı şekilde) optimize edilebilir.

Not - Bazı işlemlerde hafif bir hız cezası ve daha uzun dizelerde biraz fazladan ek yük olması karşılığında, dizelerle çalışan yöntemlerin doğrudan dizelere, sınır denetimli dize arabelleklerine veya başka bir dizenin alt dizelerini tanımlayan veri yapıları. "Strcat" gibi bir işlev [modern sözdizimi]

void strcat(unsigned char *dest, unsigned char *src)
{
  struct STRING_INFO d,s;
  str_size_t copy_length;

  get_string_info(&d, dest);
  get_string_info(&s, src);
  if (d.si_buff_size > d.si_length) // Destination is resizable buffer
  {
    copy_length = d.si_buff_size - d.si_length;
    if (s.src_length < copy_length)
      copy_length = s.src_length;
    memcpy(d.buff + d.si_length, s.buff, copy_length);
    d.si_length += copy_length;
    update_string_length(&d);
  }
}

K&R strcat yönteminden biraz daha büyük, ancak K&R yönteminin desteklemediği sınır kontrolünü destekleyecekti. Ayrıca, mevcut yöntemin aksine, rasgele bir alt dizeyi, örneğin ör.

/* Concatenate 10th through 24th characters from src to dest */

void catpart(unsigned char *dest, unsigned char *src)
{
  struct SUBSTRING_INFO *inf;
  src = temp_substring(&inf, src, 10, 24);
  strcat(dest, src);
}

Temp_substring tarafından döndürülen dize ömrü olanlar ile sınırlı olacağı Not sve srcyöntem gerektirir neden şimdiye olan (daha kısa olduğu,inf aktarılması - yerel olsaydı, yöntem döndürüldüğünde ölür).

Bellek maliyeti açısından, 64 bayta kadar olan dizeler ve arabelleklerin bir bayt ek yükü olacaktır (sıfır sonlu dizelerle aynı); daha uzun dizeler biraz daha fazla olabilir (bir kişinin iki bayt arasında izin verilen miktarlarda ek yüke izin verip vermediği, bir zaman / boşluk ödünleşimi olurdu). Uzunluk / mod baytının özel bir değeri, bir dize işlevine bir bayrak baytı, bir işaretçi ve bir arabellek uzunluğu içeren bir yapı verildiğini (daha sonra isteğe bağlı olarak başka bir dizeye dizine ekleyebileceğini) belirtmek için kullanılır.

Tabii ki, K&R böyle bir şey uygulamadı, ancak bunun nedeni büyük olasılıkla ipin işlenmesi için çok fazla çaba harcamak istemiyordu - bugün bile birçok dilin anemik göründüğü bir alan.

Bu blog yazısında Joel Spolsky'ye göre ,

Bunun nedeni, UNIX ve C programlama dilinin icat edildiği PDP-7 mikroişlemcinin ASCIZ dize tipine sahip olmasıdır. ASCIZ "sonunda Z (sıfır) olan ASCII" anlamına geliyordu.

Buradaki diğer tüm cevapları gördükten sonra, bu doğru olsa bile, C'nin boş sonlandırılmış "dizelere" sahip olmasının nedeninin sadece bir parçası olduğuna ikna oldum. Bu yazı, dizeler gibi basit şeylerin aslında oldukça zor olabileceği konusunda oldukça aydınlatıcı.

Gerekçeli olmak zorunda değil, uzunluk kodlamalı bir karşı konu

1. Bazı dinamik uzunluk kodlaması biçimleri, bellek açısından statik uzunluk kodlamasından daha üstündür, hepsi kullanıma bağlıdır. Kanıt için UTF-8'e bakmanız yeterli. Temelde tek bir karakteri kodlamak için genişletilebilir bir karakter dizisidir. Bu, her genişletilmiş bayt için tek bir bit kullanır. NUL sonlandırmasında 8 bit kullanılır. Uzunluk öneki bence 64 bit kullanılarak da makul uzunlukta sonsuz uzunluk olarak adlandırılabilir. Ekstra bitlerinizin durumuna ne sıklıkta çarptığınız belirleyici faktördür. Sadece 1 aşırı büyük dize? 8 veya 64 bit kullanıyorsanız kimin umrunda? Birçok küçük dize (İngilizce kelimelerin Ie Dizeleri)? O zaman ön ek maliyetleriniz büyük bir yüzdedir.

2. Zamandan tasarruf sağlayan uzunluk ön ekli dizeler gerçek bir şey değildir . Sağlanan verilerinizin uzunluğunun sağlanması gerekip gerekmediği, derleme zamanında sayılıyor veya dize olarak kodlamanız gereken dinamik veriler sağlanıyor. Bu boyutlar algoritmanın bir noktasında hesaplanır. Ayrı bir değişken boş sonlandırılmış dizesi boyutunu depolamak için sağlanır. Bu da zaman tasarrufu tartışmasını yapar. Birinin sonunda fazladan bir NUL var ... ama eğer uzunluk kodlaması bu NUL'u içermiyorsa, ikisi arasında hiçbir fark yoktur. Hiçbir algoritmik değişiklik gerekmez. Sadece bir ön geçiş bir derleyici / çalışma zamanı sizin için yapmak yerine kendinizi kendiniz tasarlamanız gerekir. C çoğunlukla işleri elle yapmakla ilgilidir.

3. Uzunluk öneki isteğe bağlı olmak bir satış noktasıdır. Ben her zaman bir algoritma için ekstra bilgi gerekmez her dize için yapmak için gerekli olmak benim precompute + işlem süresi asla O (n) altına düşmek mümkün kılar. (Yani donanım rasgele sayı üreteci 1-128. Bir "sonsuz dize" alabilirim. Diyelim ki sadece çok hızlı karakterler üretir. Dize uzunluğu her zaman değişir. Ama veri kullanımı benim muhtemelen nasıl umurumda değil birçok rastgele bayt var.Sadece bir istek üzerine alır almaz bir sonraki kullanılabilir kullanılmayan bayt istiyor.Cihazda bekliyor olabilirim.Ama aynı zamanda önceden okunmuş bir karakter tamponu da olabilir. gereksiz bir hesaplama israfıdır. Boş kontrol daha verimlidir.)

4. Uzunluk öneki, arabellek taşmasına karşı iyi bir koruma mı? Kitaplık fonksiyonlarının akılcı kullanımı ve uygulanması da böyledir. Yanlış biçimlendirilmiş verilerden geçersem ne olur? Arabelleğim 2 bayt uzunluğunda ama fonksiyona 7 olduğunu söylüyorum! Örn: gets () derlenmiş tamponlar ve test edilen bir iç tampon kontrolü oldu olabilir bilinen veriler üzerinde kullanılmak üzere amaçlanmıştır ) (Malloc çağırıyorsa ve hala spec'i takip ediyorsanız . Bilinmeyen STDIN'in bilinmeyen tampona ulaşması için bir boru olarak kullanılması gerekiyorsa, açıkça bir tamponun boyutuna dayanamaz, bu da uzunluk argusunun anlamsız olduğu anlamına gelir, burada bir kanarya kontrolü gibi başka bir şeye ihtiyacınız vardır. Bu nedenle, bazı akışların ve girişlerin uzunluğunda önek ekleyemezsiniz, sadece yapamazsınız. Bu, uzunluk kontrolünün, yazma sisteminin sihirli bir parçası değil, algoritmaya dahil edilmesi gerektiği anlamına gelir. TL; DR NUL tarafından sonlandırılan hiçbir zaman güvensiz olmak zorunda değildi, sadece yanlış kullanımla bu şekilde sona erdi.

5. karşı-karşı noktası: NUL-sonlandırma ikili üzerinde can sıkıcıdır. Burada uzunluk öneki yapmanız veya bir şekilde NUL baytlarını dönüştürmeniz gerekir: kaçış kodları, aralık yeniden eşleme, vb ... bu da elbette daha fazla bellek kullanımı / azaltılmış bilgi / bayt başına daha fazla işlem anlamına gelir. Uzunluk öneki çoğunlukla savaşı kazanır. Bir dönüşümün tek tarafı, uzunluk öneki dizelerini kapsayacak ek işlevlerin yazılmasına gerek olmamasıdır. Bu, daha optimize alt O (n) yordamlarınızda, daha fazla kod eklemeden otomatik olarak O (n) eşdeğerleri olarak hareket etmelerini sağlayabilirsiniz. Olumsuz, elbette, NUL ağır tellerde kullanıldığında zaman / bellek / sıkıştırma kaybıdır.Kütüphanenizin ne kadarının ikili veriler üzerinde çalışmak üzere çoğaltıldığına bağlı olarak, yalnızca uzunluk öneki dizeleriyle çalışmak mantıklı olabilir. Birinin uzunluk önek dizeleriyle de aynısını yapabileceği söylenir ... -1 uzunluk, NUL sonlandırması anlamına gelebilir ve uzunluk sonlandırılmış içinde NUL sonlandırılmış dizeleri kullanabilirsiniz.

6. Concat: "O (n + m) vs O (m)" Birleştirmeden sonra dizeye toplam uzunluk olarak m'ye atıfta bulunduğunuzu varsayıyorum çünkü her ikisinin de minimum işlem sayısına sahip olması gerekir (sadece -dize 1'e, yeniden tahsis etmeniz gerekiyorsa?). Ve n'nin bir ön hesaplama nedeniyle artık yapmak zorunda olmadığınız efsanevi bir işlem olduğunu varsayıyorum. Öyleyse, cevap basittir: ön hesaplama. Eğerher zaman yeniden tahsis etmek için yeterli belleğe sahip olacağınız konusunda ısrar edersiniz ve bu büyük O gösteriminin temelidir, o zaman cevap daha da basittir: dize 1'in sonu için ayrılan bellekte ikili arama yapın, açıkça büyük bir şey var realloc hakkında endişelenmemek için dize 1'den sonra sonsuz sıfırların renk örneği. Orada, kolayca n giriş (n) var ve zorlukla denedim. Eğer günlük (n) 'yi hatırlarsanız gerçek bir bilgisayarda sadece 64 kadar büyüktür, bu da esasen O (m) olan O (64 + m) demek gibidir. (Ve evet bu mantık bugün kullanımda olan gerçek veri yapılarının çalışma zamanı analizinde kullanılmıştır. Başımın üstünden saçmalık değil.)

7. Concat () / Len () _tekrar : Sonuçları not edin. Kolay. Mümkünse / gerekirse tüm hesaplamaları ön hesaplamalara dönüştürür. Bu algoritmik bir karardır. Bu, dilin zorunlu bir kısıtlaması değildir.

8. Dize sonlandırma ile dize soneki iletimi daha kolay / mümkündür. Uzunluk önekinin nasıl uygulandığına bağlı olarak, orijinal dizede yıkıcı olabilir ve bazen bile mümkün olmayabilir. Kopyalama ve O (1) yerine O (n) geçmesi gerekiyor.

9. Bağımsız değişken geçirme / referans gösterme, uzunluk önekine göre NUL sonlandırması için daha azdır. Açıkçası daha az bilgi aktardığınız için. Uzunluğa ihtiyacınız yoksa, bu çok fazla yer tasarrufu sağlar ve optimizasyonlara izin verir.

10. Hile yapabilirsiniz. Gerçekten sadece bir işaretçi. Kim bir dize olarak okumak zorunda diyor? Tek bir karakter veya kayan nokta olarak okumak isterseniz ne olur? Ya tam tersini yapmak ve bir kayan reklamı dize olarak okumak isterseniz? Eğer dikkatli olursanız, bunu NUL sonlandırma ile yapabilirsiniz. Uzunluk önekiyle bunu yapamazsınız, bu genellikle bir işaretçiden belirgin şekilde farklı bir veri türüdür. Büyük olasılıkla bir bayt bayt dizesi oluşturmanız ve uzunluğu elde etmeniz gerekir. Tabii ki tüm bir şamandıra gibi bir şey istiyorsanız (muhtemelen içinde bir NUL vardır) yine de bayt bayt okumak zorunda kalırsınız, ancak ayrıntılar karar vermek için size bırakılır.

TL; DR İkili veri mi kullanıyorsunuz? Hayır ise, NUL sonlandırma daha fazla algoritmik özgürlüğe izin verir. Evet ise, hız / bellek / sıkıştırmaya karşı kod miktarı ana endişenizdir. İki yaklaşımın veya notun bir karışımı en iyisi olabilir.

"C dizesi yok" cevabını satın almıyorum. Doğru, C yerleşik üst düzey türleri desteklemez, ancak yine de C'deki veri yapılarını temsil edebilirsiniz ve bir dize budur. Bir dizginin sadece C'deki bir işaretçi olması, ilk N baytın uzunluk olarak özel bir anlam taşıyamayacağı anlamına gelmez.

Windows / COM geliştiricileri BSTR, tam olarak böyle olan türe çok aşinadır - gerçek karakter verilerinin bayt 0'da başlamadığı, uzunluk ön ekli bir C dizesi.

Öyleyse, null sonlandırma kullanma kararı, dilin bir zorunluluğu değil, insanların tercih ettiği şeydir.

gcc aşağıdaki kodları kabul eder:

char s [4] = "abcd";

ve biz tedavi eğer karakter dizisi olarak ama dize değil tamam. Yani, s [0], s [1], s [2] ve s [3] ile veya hatta memcpy (dest, s, 4) ile erişebiliriz. Ancak, koyar (lar) ile denediğimizde ya da strcpy (dest, s) ile daha da kötüyken dağınık karakterler elde edeceğiz.