Dize ve karakter sabitleri (C++)

C++ çeşitli dize ve karakter türlerini destekler ve bu türlerden her birinin değişmez değerlerini ifade etmenin yollarını sağlar. Kaynak kodunuzda, karakter kümenizi ve dize değişmez değerlerinizin içeriğini bir karakter kümesi kullanarak ifade edersiniz. Evrensel karakter adları ve kaçış karakterleri, yalnızca temel kaynak karakter kümesini kullanarak herhangi bir dizeyi ifade etmenizi sağlar. Ham dize değişmez değeri, kaçış karakterleri kullanmaktan kaçınmanızı sağlar ve tüm dize değişmez değer türlerini ifade etmek için kullanılabilir. Ekstra yapım veya dönüştürme adımları gerçekleştirmeden değişmez değerler std::string oluşturabilirsiniz.

#include <string>
using namespace std::string_literals; // enables s-suffix for std::string literals

int main()
{
    // Character literals
    auto c0 =   'A'; // char
    auto c1 = u8'A'; // char
    auto c2 =  L'A'; // wchar_t
    auto c3 =  u'A'; // char16_t
    auto c4 =  U'A'; // char32_t

    // Multicharacter literals
    auto m0 = 'abcd'; // int, value 0x61626364

    // String literals
    auto s0 =   "hello"; // const char*
    auto s1 = u8"hello"; // const char* before C++20, encoded as UTF-8,
                         // const char8_t* in C++20
    auto s2 =  L"hello"; // const wchar_t*
    auto s3 =  u"hello"; // const char16_t*, encoded as UTF-16
    auto s4 =  U"hello"; // const char32_t*, encoded as UTF-32

    // Raw string literals containing unescaped \ and "
    auto R0 =   R"("Hello \ world")"; // const char*
    auto R1 = u8R"("Hello \ world")"; // const char* before C++20, encoded as UTF-8,
                                      // const char8_t* in C++20
    auto R2 =  LR"("Hello \ world")"; // const wchar_t*
    auto R3 =  uR"("Hello \ world")"; // const char16_t*, encoded as UTF-16
    auto R4 =  UR"("Hello \ world")"; // const char32_t*, encoded as UTF-32

    // Combining string literals with standard s-suffix
    auto S0 =   "hello"s; // std::string
    auto S1 = u8"hello"s; // std::string before C++20, std::u8string in C++20
    auto S2 =  L"hello"s; // std::wstring
    auto S3 =  u"hello"s; // std::u16string
    auto S4 =  U"hello"s; // std::u32string

    // Combining raw string literals with standard s-suffix
    auto S5 =   R"("Hello \ world")"s; // std::string from a raw const char*
    auto S6 = u8R"("Hello \ world")"s; // std::string from a raw const char* before C++20, encoded as UTF-8,
                                       // std::u8string in C++20
    auto S7 =  LR"("Hello \ world")"s; // std::wstring from a raw const wchar_t*
    auto S8 =  uR"("Hello \ world")"s; // std::u16string from a raw const char16_t*, encoded as UTF-16
    auto S9 =  UR"("Hello \ world")"s; // std::u32string from a raw const char32_t*, encoded as UTF-32
}

Dize değişmezleri herhangi bir ön eke sahip olmayabilir veya dar karakter (tek bayt veya çok baytlı), UTF-8, geniş karakter (UCS-2 veya UTF-16), UTF-16 ve UTF-32 kodlamalarını belirtmek için sırasıyla u8, L, u, ve U ön eklerine sahip olabilir. Ham dize değişmez değeri, bu kodlamaların ham sürüm eşdeğerleri için R, u8R, LR, uR ve UR ön eklerine sahip olabilir. Geçici veya statik std::string değerler oluşturmak için dize değişmez değerlerini veya sonek s içeren ham dize değişmez değerlerini kullanabilirsiniz. Daha fazla bilgi için "Dize sabitleri" bölümüne aşağıda bakın. Temel kaynak karakter kümesi, evrensel karakter adları ve kaynak kodunuzda genişletilmiş kod sayfalarındaki karakterleri kullanma hakkında daha fazla bilgi için bkz . Karakter kümeleri.

Karakter değişmez değerleri

Karakter sabiti sabit bir karakterden oluşur. Bu, tek tırnak işaretleri ile çevrili bir karakter ile temsil edilir. Beş tür karakter sabiti vardır.

• Türü char olan sıradan karakter değişmez değerleri, örneğin 'a'

• UTF-8 karakter sabit değerleri türü char (char8_t C++20'de), örneğin u8'a'

• wchar_t türündeki geniş karakter sabitleri, örneğin L'a'

• UTF-16 karakter sabit değerleri türü char16_t, örneğin u'a'

• UTF-32 türündeki karakter sabitleri char32_t, örneğin U'a'

Karakter değişmez değeri için kullanılan karakter, ayrılmış karakterler olan ters eğik çizgi (\), tek tırnak işareti (') veya yeni satır dışında herhangi bir karakter olabilir. Ayrılmış karakterler bir kaçış dizisi kullanılarak belirtilebilir. Karakter türü, karakteri barındıracak kadar büyük olduğu sürece, karakterler evrensel karakter adları kullanılarak belirtilebilir.

Kodlama

Karakter sabitleri ön eklerine göre farklı şekilde kodlanır.

• Ön eki olmayan bir karakter değişmez değeri, normal bir karakter değişmez değeridir. Yürütme karakter kümesinde temsil edilebilen tek bir karakter, kaçış dizisi veya evrensel karakter ismi içeren sıradan bir karakter sabitinin değeri, yürütme karakter kümesindeki kodlamasının sayısal değeriyle eşittir. Birden fazla karakter, kaçış dizisi veya evrensel karakter adı içeren sıradan bir karakter değişmezi, çok karakterli değişmezidir. Temsil edilemeyen çok karakterli bir sabit değer veya yürütme karakter kümesinde temsil edilemeyen sıradan bir karakter sabiti int türüne sahiptir ve değeri uygulamaya göre tanımlanmıştır. MSVC için aşağıdaki Microsoft'a özgü bölüme bakın.

• Ön ek ile L başlayan bir karakter değişmez değeri, geniş karakter değişmez değeridir. Tek bir karakter, kaçış dizisi veya evrensel karakter adı içeren geniş karakter değişmezinin değeri, yürütme geniş karakter kümesindeki kodlamasının sayısal değerine eşittir; ancak, karakter değişmez yürütme geniş karakter kümesinde temsili yoksa, bu durumda değer uygulama tarafından tanımlanır. Birden çok karakter, kaçış dizisi veya evrensel karakter adı içeren geniş karakterli değişmez ifadenin değeri, uygulamaya göre belirlenir. MSVC için aşağıdaki Microsoft'a özgü bölüme bakın.

• u8 öneki ile başlayan bir karakter sabiti, UTF-8 karakter sabitidir. Tek bir karakter, kaçış dizisi veya evrensel karakter adı içeren UTF-8 karakter değişmez değerinin değeri, tek bir UTF-8 kod birimiyle (C0 Denetimleri ve Temel Latin Unicode bloğuna karşılık gelen) temsil edilebiliyorsa, ISO 10646 kod noktası değerine eşit bir değere sahiptir. Değer tek bir UTF-8 kod birimiyle temsil edilemiyorsa, program kötü biçimlendirilmiş olur. Birden fazla karakter, kaçış dizisi veya evrensel karakter adı içeren UTF-8 karakter değişmez değeri hatalı biçimlendirilmiş.

• u önekiyle başlayan bir karakter sabiti, bir UTF-16 karakter sabitidir. Tek bir karakter, kaçış dizisi veya evrensel karakter adı içeren UTF-16 karakter değişmez değerinin değeri, tek bir UTF-16 kod birimiyle (temel çok dilli düzleme karşılık gelen) temsil edilebiliyorsa, ISO 10646 kod noktası değerine eşit bir değere sahiptir. Değer tek bir UTF-16 kod birimiyle temsil edilemiyorsa, program kötü biçimlendirilmiş olur. Birden fazla karakter, kaçış dizisi veya evrensel karakter adı içeren bir UTF-16 karakter sabiti hatalı oluşturulmuştur.

• U öneki ile başlayan bir karakter değişmez değeri, bir UTF-32 karakter değişmez değeridir. Tek bir karakter, kaçış dizisi veya evrensel karakter adı içeren bir UTF-32 karakter sabitinin değeri, ISO 10646 kod noktası değerine eşittir. Birden fazla karakter, kaçış dizisi veya evrensel karakter adı içeren UTF-32 karakter sabit değeri hatalı biçimlendirilmiş.

Çıkış sıraları

Üç tür kaçış dizisi vardır: basit, sekizli ve onaltılık. Kaçış dizileri aşağıdaki değerlerden biri olabilir:

Değer	Kaçış dizisi
yeni satır	\n
ters eğik çizgi	\\
yatay sekme	\t
soru işareti	? veya ?
dikey sekme	\v
tek tırnak	\'
geri silme tuşu	\b
çift tırnak işareti	\"
taşıyıcı dönüşü	\r
null karakter	\0
form besleme	\f
sekizlik	\ooo
uyarı (zil)	\a
onaltılık	\xhhh

Sekizli kaçış dizisi, ters eğik çizginin ardından bir ila üç sekizli basamak içeren bir dizidir. Sekizli kaçış dizisi, üçüncü basamaktan önce karşılaşılan sekizli basamak olmayan ilk karakterde sonlandırılır. Mümkün olan en yüksek sekizli değerdir \377.

Onaltılık kaçış dizisi, bir ters eğik çizgi, ardından x karakteri ve ardından bir veya daha fazla onaltılık basamaktan oluşan bir dizidir. Başlangıçtaki sıfırlar dikkate alınmaz. Normal veya u8 önekli bir karakter sabitinde en yüksek onaltılık değer 0xFF'tir. L veya u ön ekiyle kullanılan geniş karakter sabitinde en yüksek onaltılık değer 0xFFFF'dir. U ön ekine sahip geniş karakter sabitinde en yüksek onaltılık değer 0xFFFFFFFF.

Bu örnek kod, sıradan karakter değişmez değerleri kullanan kaçış karakterlerinin bazı örneklerini gösterir. Aynı kaçış dizisi söz dizimi diğer karakter sabiti türleri için de geçerlidir.

#include <iostream>
using namespace std;

int main() {
    char newline = '\n';
    char tab = '\t';
    char backspace = '\b';
    char backslash = '\\';
    char nullChar = '\0';

    cout << "Newline character: " << newline << "ending" << endl;
    cout << "Tab character: " << tab << "ending" << endl;
    cout << "Backspace character: " << backspace << "ending" << endl;
    cout << "Backslash character: " << backslash << "ending" << endl;
    cout << "Null character: " << nullChar << "ending" << endl;
}
/* Output:
Newline character:
ending
Tab character:  ending
Backspace character:ending
Backslash character: \ending
Null character:  ending
*/

Ters eğik çizgi karakteri (\), bir satırın sonuna yerleştirildiğinde satır devamlılığı karakteridir. Ters eğik çizgi karakterinin karakter olarak görünmesini istiyorsanız, art arda iki ters eğik çizgi yazmanız gerekir. Satır devamlılığı karakteri hakkında daha fazla bilgi için bkz. Çeviri Aşamaları.

Microsoft'a özgü

Dar bir çok karakterli sabit değerden değer oluşturmak için, derleyici tek tırnaklar arasındaki karakter veya karakter dizisini 32 bitlik bir tamsayı içinde 8 bit değerlere dönüştürür. Birebir dolgu işlemi sırasında birden çok karakter, yüksek bayttan düşük bayta doğru gereken şekilde karşılık gelen baytları doldurur. Derleyici daha sonra tamsayıyı normal kurallara göre hedef türe dönüştürür. Örneğin, bir char değer oluşturmak için derleyici düşük sıralı bayt alır. Bir wchar_t veya char16_t değeri oluşturmak için, derleyici düşük sıra sözcüğünü alır. Derleyici, atanan bayt veya sözcüğün ötesinde herhangi bir bit ayarlanırsa sonucun kesileceği konusunda uyarıda bulunur.

char c0    = 'abcd';    // C4305, C4309, truncates to 'd'
wchar_t w0 = 'abcd';    // C4305, C4309, truncates to '\x6364'
int i0     = 'abcd';    // 0x61626364

Üçten fazla basamak içeriyor gibi görünen sekizli kaçış dizisi, 3 basamaklı sekizli sıra olarak kabul edilir ve ardından izleyen basamaklar çok karakterli sabit değerde karakterler olarak kabul edilir ve bu da şaşırtıcı sonuçlar verebilir. Örneğin:

char c1 = '\100';   // '@'
char c2 = '\1000';  // C4305, C4309, truncates to '0'

Sekizli olmayan karakterler içeriyor gibi görünen kaçış dizileri, son sekizli karaktere kadar sekizlik bir sıra olarak değerlendirilir ve ardından kalan karakterler çok karakterli sabit değerde sonraki karakterler olarak değerlendirilir. İlk sekizli olmayan karakter ondalık basamaksa C4125 uyarısı oluşturulur. Örneğin:

char c3 = '\009';   // '9'
char c4 = '\089';   // C4305, C4309, truncates to '9'
char c5 = '\qrs';   // C4129, C4305, C4309, truncates to 's'

Değeri \377'dan yüksek olan bir sekizlik kaçış dizisi, hata C2022'ye neden olur: 'ondalık-değer': karaktere sığamayacak kadar büyük.

Onaltılık ve onaltılık olmayan karakterlere sahip gibi görünen bir kaçış dizisi, son onaltılık karaktere kadar onaltılık bir kaçış dizisi ve ardından onaltılık olmayan karakterler içeren çok karakterli sabit değer olarak değerlendirilir. Onaltılık basamak içermeyen bir onaltılık kaçış dizisi, derleyici hatası C2153'e neden olur: "onaltılık sayılarda en az bir onaltılık basamak olmalıdır".

char c6 = '\x0050'; // 'P'
char c7 = '\x0pqr'; // C4305, C4309, truncates to 'r'

Eğer L ile öneklenen geniş karakter sabiti çok karakterli bir dizi içeriyorsa, değer ilk karakterden alınır ve derleyici C4066 uyarısını verir. Eşdeğer sıradan çok karakterli sabit değerin davranışından farklı olarak sonraki karakterler yoksayılır.

wchar_t w1 = L'\100';   // L'@'
wchar_t w2 = L'\1000';  // C4066 L'@', 0 ignored
wchar_t w3 = L'\009';   // C4066 L'\0', 9 ignored
wchar_t w4 = L'\089';   // C4066 L'\0', 89 ignored
wchar_t w5 = L'\qrs';   // C4129, C4066 L'q' escape, rs ignored
wchar_t w6 = L'\x0050'; // L'P'
wchar_t w7 = L'\x0pqr'; // C4066 L'\0', pqr ignored

Microsoft'a özgü bölüm burada sona erer.

Evrensel karakter adları

Karakter değişmezleri ve yerleşik (ham olmayan) dize değişmezlerinde, herhangi bir karakter evrensel karakter ismiyle temsil edilebilir. Evrensel karakter adları, sekiz basamaklı Unicode kod noktası için bir ön ek \U ve dört basamaklı Unicode kod noktası için bir ön ek \u ile oluşturulur. İyi biçimlendirilmiş bir evrensel karakter adı oluşturmak için sırasıyla sekiz veya dört basamak da mevcut olmalıdır.

char u1 = 'A';          // 'A'
char u2 = '\101';       // octal, 'A'
char u3 = '\x41';       // hexadecimal, 'A'
char u4 = '\u0041';     // \u UCN 'A'
char u5 = '\U00000041'; // \U UCN 'A'

Vekil Çiftler

Evrensel karakter adları, D800-DFFF vekil kod noktası aralığındaki değerleri kodlayamaz. Unicode vekil çiftleri için, \UNNNNNNNN kullanarak evrensel karakter adını belirtin. Burada NNNNNNNN, karakterin sekiz basamaklı kod noktasıdır. Derleyici gerekirse bir vekil çift oluşturur.

C++03'te, dil yalnızca bir karakter alt kümesinin evrensel karakter adlarıyla temsil edilmesine izin verdi ve aslında geçerli Unicode karakterlerini temsil etmeyen bazı evrensel karakter adlarına izin verdi. Bu hata C++11 standardında düzeltildi. C++11'de hem karakter hem de dize değişmez değerleri ve tanımlayıcılar evrensel karakter adlarını kullanabilir. Evrensel karakter adları hakkında daha fazla bilgi için bkz . Karakter Kümeleri. Unicode hakkında daha fazla bilgi için bkz . Unicode. Vekil çiftler hakkında daha fazla bilgi için bkz . Vekil Çiftler ve Ek Karakterler.

Dize sabitleri

** Bir string değişmez değeri, null karakteri ile sonlandırılan bir karakter dizisini temsil eder. Karakterler çift tırnak içine alınmalıdır. Aşağıdaki dize sabitleri vardır:

Dar dize değişmez değerleri

Türü const char[n] olan dar bir dize, ön ek olmadan, çift tırnak içerisinde sınırlandırılmış ve null ile sonlandırılmış bir bayt dizisidir, burada n, dizinin bayt cinsinden uzunluğudur. Dar dize değişmez değeri, çift tırnak işareti ("), ters eğik çizgi (\) veya yeni satır karakteri dışında herhangi bir grafik karakteri içerebilir. Dar dize sabit değeri, yukarıda listelenen kaçış dizilerini ve bayt içine sığan evrensel karakter adlarını da içerebilir.

const char *narrow = "abcd";

// represents the string: yes\no
const char *escaped = "yes\\no";

UTF-8 kodlanmış dizeler

UTF-8 kodlanmış dize u8 önekli, çift tırnakla ayrılmış, null olarak sonlandırılan türünde const char[n]bir dizidir; burada n , kodlanmış dizinin bayt cinsinden uzunluğudur. U8 ile öneklenmiş dize sabiti, çift tırnak işareti ("), ters eğik çizgi (\) veya yeni satır karakteri dışında herhangi bir grafik karakteri içerebilir. u8 ile başlayan bir dize değişmez değeri, yukarıda listelenen kaçış dizilerini ve herhangi bir evrensel karakter adını da içerebilir.

C++20 taşınabilir char8_t (UTF-8 kodlanmış 8 bit Unicode) karakter türünü tanıtır. C++20'de u8 literal önekleri, char yerine char8_t karakterlerini veya dizelerini belirtmek için kullanılır.

// Before C++20
const char* str1 = u8"Hello World";
const char* str2 = u8"\U0001F607 is O:-)";
// C++20 and later
const char8_t* u8str1 = u8"Hello World";
const char8_t* u8str2 = u8"\U0001F607 is O:-)";

Geniş dize değişmez değerleri

Geniş dize değişmez değeri, 'L' ön ekli olan ve çift tırnak işareti ("), ters eğik çizgi (\) veya yeni satır karakteri dışında herhangi bir grafik karakteri içeren ve null ile sonlandırılan bir sabit wchar_t dizisidir. Geniş bir dize sabiti, yukarıda listelenen kaçış dizilerini ve herhangi bir evrensel karakter adını içerebilir.

const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";

char16_t ve char32_t (C++11)

C++11 taşınabilir char16_t (16 bit Unicode) ve char32_t (32 bit Unicode) karakter türlerini tanıtır:

auto s3 = u"hello"; // const char16_t*
auto s4 = U"hello"; // const char32_t*

Ham dize sabitleri (C++11)

Ham dize literal, çift tırnak işareti ("), ters eğik çizgi (\) veya yeni satır karakteri de dahil olmak üzere herhangi bir grafik karakter içeren, herhangi bir karakter türünde null olarak sonlandırılan bir dizidir. Ham dize değişmez değerleri genellikle karakter sınıflarını kullanan normal ifadelerde ve HTML dizeleri ile XML dizelerinde kullanılır. Örnekler için şu makaleye bakın: Bjarne Stroustrup'un C++11 hakkında SSS'si.

// represents the string: An unescaped \ character
const char* raw_narrow = R"(An unescaped \ character)";
const wchar_t*  raw_wide  = LR"(An unescaped \ character)";
const char*     raw_utf8a = u8R"(An unescaped \ character)"; // Before C++20
const char8_t*  raw_utf8b = u8R"(An unescaped \ character)"; // C++20
const char16_t* raw_utf16 = uR"(An unescaped \ character)";
const char32_t* raw_utf32 = UR"(An unescaped \ character)";

"Sınırlandırıcı, ham metin sözselinin (literal) açılış parantezinin tam önünde ve kapama parantezinin tam sonrasında yer alan, en fazla 16 karakterden oluşan kullanıcı tanımlı bir dizidir." Örneğin, sınırlayıcı dizisi R"abc(Hello"\()abc" ve abc'dir ve dize içeriği ise Hello"\('dir. Hem çift tırnak işaretleri hem de parantezler içeren ham dizeleri ayırmak için sınırlayıcı kullanabilirsiniz. Bu dize sabiti, derleyici hatasına neden olur.

// meant to represent the string: )"
const char* bad_parens = R"()")";  // error C2059

Ancak sınırlayıcı bunu çözer:

const char* good_parens = R"xyz()")xyz";

Yeni bir satır içeren (kaçış karakteri değil) bir ham dize kaynakta oluşturabilirsiniz.

// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";

std::string literal'ları (C++14)

std::string sabitler, kullanıcı tanımlı sabitlerin Standart Kütüphane uygulamalarıdır (aşağıya bakın) ve bunlar s son ekiyle temsil edilir. Bu tür bir string değer, belirtilen ön eke bağlı olarak std::string, std::wstring, std::u32string veya std::u16string türünde geçici bir nesne oluşturur. Yukarıdaki gibi ön ek kullanılmadığında bir std::string oluşturulur. L"xyz"s bir std::wstringüretir. u"xyz"s bir std::u16string ve U"xyz"s bir std::u32string üretir.

//#include <string>
//using namespace std::string_literals;
string str{ "hello"s };
string str2{ u8"Hello World" };     // Before C++20
u8string u8str2{ u8"Hello World" }; // C++20
wstring str3{ L"hello"s };
u16string str4{ u"hello"s };
u32string str5{ U"hello"s };

Son ek s, işlenmemiş dize sabit değerlerinde de kullanılabilir.

u32string str6{ UR"(She said "hello.")"s };

std::stringdeğişmez değerler, <dize> başlık dosyasındaki std::literals::string_literals ad alanında tanımlanır. std::literals::string_literals ve std::literalsher ikisi de satır içi ad alanları olarak bildirildiğinden, std::literals::string_literals otomatik olarak doğrudan ad alanına stdaitmiş gibi kabul edilir.

Dize değişmez değerlerinin boyutu

ANSI char* dizeleri ve UTF-8 hariç diğer tek baytlı kodlamalar için, bir dize değişmez değerinin boyutu (bayt cinsinden), karakter sayısına sonlandırıcı null karakteri ekleyerek hesaplanır. Diğer tüm dize türleri için boyut, karakter sayısıyla kesin olarak ilişkili değildir. UTF-8, bazı kod birimlerini kodlamak için en çok dört char öğe kullanır ve veya char16_t UTF-16 olarak kodlanmış tek bir wchar_t kodlamak için iki öğe (toplam dört bayt için) kullanabilir. Bu örnek, geniş bir dize değişmez değerinin bayt cinsinden boyutunu gösterir:

const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);

strlen() ve wcslen() sonlandırıcı null karakterin boyutunu, yani dize türünün öğe boyutuna eşit olan birimi içermez: char* veya char8_t* dizelerde bir bayt, wchar_t* veya char16_t* dizelerde iki bayt ve char32_t* dizelerde dört bayt.

Birleştirmeden sonra dize değişmezinin maksimum uzunluğu:

• Visual Studio 2022 sürüm 17.0'dan önce: Birleştirmeden sonra bir dize sabitinin maksimum uzunluğu 65.535 bayttır. Bu, hem dar hem de geniş dize sabitleri için geçerlidir.
• Visual Studio 2022 sürüm 17.0'dan itibaren: Birleştirmeden sonra dize uzunluğu üst sınırı yalnızca kullanılabilir bellekle sınırlıdır. Ancak birleştirmeden önce boyut sınırı hala 16.384 bayttır

Dize sabitlerini değiştirme

Dize değişmez değerleri (değişmez değerler dahil std::string değil) sabit olduğundan, bunları değiştirmeye çalışmak (örneğin, str[2] = 'A') derleyici hatasına neden olur.

Microsoft'a özgü

Microsoft C++'da, sabit olmayan char veya wchar_t işaretçisini başlatmak için bir dize değişmez değeri kullanabilirsiniz. Bu sabit olmayan başlatmaya C99 kodunda izin verilir, ancak C++98'de kullanım dışıdır ve C++11'de kaldırılır. Dizeyi değiştirme girişimi, aşağıdaki örnekte olduğu gibi erişim ihlaline neden olur:

wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation

(Dize değişmez değer türü dönüştürmeyi devre dışı bırak) derleyici seçeneğini ayarladığınızda, bir dize değişmez değeri sabit olmayan bir karakter işaretçisine dönüştürüldüğünde derleyiciyi bir hata vermeye zorlayabilirsiniz. Standartlara uygun taşınabilir kod için bunu öneririz. Aynı zamanda, doğru (const) türüne çözümlediği için dize değişmez değeriyle başlatılan işaretçileri bildirmek amacıyla auto anahtar sözcüğünü kullanmak da iyi bir uygulamadır. Örneğin, bu kod örneği derleme zamanında sabit bir dizeye yazma girişimini yakalar.

auto str = L"hello";
str[2] = L'a'; // C3892: you cannot assign to a variable that is const.

Bazı durumlarda, aynı dize değişmez değerleri çalıştırılabilir dosyada yer kazanmak için ortak kullanılabilir. Dize sabiti havuzunda, derleyici belirli bir dize sabitine yapılan tüm başvuruların bellekte aynı konuma işaret etmesini sağlar, böylece her başvuru ayrı bir dize sabiti örneğine işaret etmez. Dize havuzunu etkinleştirmek için derleyici seçeneğini kullanın /GF .

Microsoft'a özgü bölüm burada sona erer.

Bitişik dize sabitlerini birleştirme

Bitişik geniş veya dar string sabitleri birleştirilir. Bu bildirim:

char str[] = "12" "34";

bu bildirimle aynıdır:

char atr[] = "1234";

ve bu bildirime:

char atr[] =  "12\
34";

Dize sabitlerini belirtmek için katıştırılmış onaltılık kaçış kodlarının kullanılması beklenmeyen sonuçlara neden olabilir. Aşağıdaki örnek, ASCII 5 karakterini ve ardından f, i, v ve e karakterlerini içeren bir dize değişmez değeri oluşturmayı arar:

"\x05five"

Gerçek sonuç, alt çizginin ASCII kodu olan onaltılık 5F ve ardından i, v ve e karakterleridir. Doğru sonucu almak için şu kaçış dizilerinden birini kullanabilirsiniz:

"\005five"     // Use octal literal.
"\x05" "five"  // Use string splicing.

std::string değişmez değerleri (ve ilgili std::u8string, std::u16string, ve std::u32string) basic_string türleri için tanımlanan + operatörü ile birleştirilebilir. Bunlar bitişik dize sabitleriyle aynı şekilde de birleştirilebilir. Her iki durumda da dize kodlaması ve sonek eşleşmelidir:

auto x1 = "hello" " " " world"; // OK
auto x2 = U"hello" " " L"world"; // C2308: disagree on prefix
auto x3 = u8"hello" " "s u8"world"z; // C3688, disagree on suffixes

Evrensel karakter adlarına sahip dize değişmezleri

Ham olmayan (hazır) dize sabitleri, evrensel karakter adı dize türünde bir veya daha fazla karakter olarak kodlanabildiği sürece, herhangi bir karakteri temsil etmek için evrensel karakter adlarını kullanabilir. Örneğin, genişletilmiş bir karakteri temsil eden evrensel karakter adı ANSI kod sayfası kullanılarak dar bir dizede kodlanamaz, ancak bazı çok baytlı kod sayfalarında veya UTF-8 dizelerinde veya geniş bir dizede dar dizelerde kodlanabilir. C++11'de Unicode desteği char16_t* ve char32_t* dize türleriyle genişletilir, C++20 ise bu desteği char8_t türüne kadar genişletir.

// ASCII smiling face
const char*     s1 = ":-)";

// UTF-16 (on Windows) encoded WINKING FACE (U+1F609)
const wchar_t*  s2 = L"😉 = \U0001F609 is ;-)";

// UTF-8  encoded SMILING FACE WITH HALO (U+1F607)
const char*     s3a = u8"😇 = \U0001F607 is O:-)"; // Before C++20
const char8_t*  s3b = u8"😇 = \U0001F607 is O:-)"; // C++20

// UTF-16 encoded SMILING FACE WITH OPEN MOUTH (U+1F603)
const char16_t* s4 = u"😃 = \U0001F603 is :-D";

// UTF-32 encoded SMILING FACE WITH SUNGLASSES (U+1F60E)
const char32_t* s5 = U"😎 = \U0001F60E is B-)";

Ayrıca bkz.

Karakter kümeleri
Sayısal, Boole ve işaretçi değişmez değerleri
Kullanıcı tanımlı literaller