النوع std::string والذي يدعى السلسلة النصية في العربية هو كائن يمثّل سلاسل من المحارف، ويوفر صنف string القياسي خيارًا بسيطًا وآمنًا ومتعدّد الاستخدامات لتخزين سلاسل المحارف ومعالجتها، وذلك موازنة بمصفوفات المحارف، و‎string‎ هو جزء من فضاء الاسم ‎std‎، وقد صار معياريًا في عام 1998.

تقطيع السلاسل النصية

يمكن تقطيع سلسلة نصيَّة إلى سلاسل نصيَّة أصغر تدعى الوحدات أو القطع (tokens)، تُسمّى هذه العمليَّة بالترميز المُقطَّع للسلاسل النصيَّة أو تقطيع السلاسل النصية (String Tokenization).

ولدينا عدّة طرق لتقطيع سلسلة نصّية، وسنُدرجها من الأقل إلى الأكثر تكلفة في وقت التشغيل:

• الطريقة الأولى: ‎std::strtok‎ 

هي أقل طرق تقطيع السلاسل النصّية تكلفة، كما تسمح بتعديل الفاصل (delimiter) بين القطع (tokens)، غير أن هذه الطريقة تعتريها ثلاثة إشكاليات في C++‎:

• لا يمكن استخدام ‎std::strtok‎ على عدّة سلاسل نصّية في نفس الوقت (باستثناء بعض التطبيقات implementations التي تمكّن من ذلك، مثل: ‎strtok_s‎)
• لا يمكن استخدام ‎std::strtok‎ على عدّة خيوط أو عمليات (threads) في وقت واحد (لكن قد يتغيّر ذلك بحسب التطبيق كما هو الحال في Visual Studio)
• استدعاء ‎std::strtok‎ يُعدّل السلسلة النصية التي يعمل عليها، لذلك لا يمكن استخدامه على السلاسل النصّية من النوع const strings أو ‎‎const char*‎ أو السلاسل النصية المجردة، ويجب نسخ السلاسل النصّية المُدخلة لتقطيع أيٍّ من هذه السلاسل باستخدام ‎std::strtok‎ أو للعمل على السلاسل النصّية التي ينبغي حفظ محتوياتها، ثم يمكن العمل على النسخة بعد ذلك .

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

ستكون تكلفة هذه الخيارات جزءًا من تكلفة حجز القطع، لكن إذا كنت تريد استخدام خوارزميات سريعة ولم تتمكن من تجاوز إشكاليات ‎std::strtok‎، فربما عليك النظر في خيار hand-spun solution.

// السلسلة النصية المراد تقطيعها
std::string str {
    "The quick brown fox"
};
// المتجه الذي سنخزن فيه القطع.
vector < std::string > tokens;
for (auto i = strtok( & str[0], " "); i != NULL; i = strtok(NULL, " "))
    tokens.push_back(i);

انظر هذا المثال الحي.

• الطريقة الثانية: ‎std::istream_iterator‎

يستخدم std::istream_iterator‎ هنا عامل الاستخراج من المجرى بشكل تكراري، وإذا كانت السلسلة النصّية المعطاة مفصولة بمسافات فارغة فسنستطيع التوسعة على المعامِل ‎std::strtok‎ بالتخلص من صعوباته، مما يسمح بالترميز المقطَّع المُضمَّن (inline)، ومن ثم دعم إنشاء متجهات السلاسل النصّية الثابتة (‎const vector<string>‎) ودعم محرف مسافات فاصلة متعددة، انظر:

// السلسلة النصية المراد تقطيعها
const std::string str("The  quick \tbrown \nfox");
std::istringstream is(str);
// المتجه الذي سنخزن فيه القطع.
const std::vector<std::string> tokens =    std::vector<std::string>(
std::istream_iterator<std::string>(is),
std::istream_iterator<std::string>());

انظر هذا المثال الحي.

• الطريقة الثالثة: std::regex_token_iterator‎

تَستخدم ‎std::regex_token_iterator‎ تعبيرًا نمطيًّا أو ‎std::regex‎ للقيام بعملية التقطيع بشكل تكراري، وهذا يسمح بتعريف الفاصل بشكل أكثر مرونة، مثل الفاصلات , والمسافات الفارغة، انظر:

الإصدار ≥ C++‎ 11

// السلسلة النصية المُراد تقطيعها
const std::string str {
    "The ,qu\\,ick ,\tbrown, fox"
};
const std::regex re {
    "\\s*((?:[^\\\\,]|\\\\.)*?)\\s*(?:,|$)"
};
// المتجه الذي سنخزن فيه القطع.
const std::vector < std::string > tokens {
    std::sregex_token_iterator(str.begin(), str.end(), re, 1),
        std::sregex_token_iterator()
};

انظر هذا المثال الحي، وهذا مثال آخر في درس التعابير النمطية للمزيد من التفاصيل.

التحويل إلى مؤشر ‎ (const)‎ char*‎

استخدم الدالة التابعة ‎c_str()‎ لتمكين مؤشّر ‎const char*‎ من الوصول إلى بيانات سلسلة نصّية، واعلم أنّ المؤشّر يبقى صالحًا ما دامت السلسلة النصّية ضمن النطاق (scope) ولم يمسّها تغيير، هذا يعني أنه لا يمكن استدعاء توابع غير ثابتة على الكائن.

الإصدار ≥ C++‎ 17

استخدم الدالة التابعة ‎data()‎ للحصول على مؤشّر قابل للتغيير ‎char*‎، والذي يمكن استخدامه لمعالجة السلسلة النصّية.

الإصدار ≥ C++‎ 11

ويمكن الحصول على مؤشّر ‎char*‎ قابل للتعديل عن طريق أخذ عنوان الحرف الأول: ‎&s[0‎]‎، سيُعيد ذلك في C++‎ 11 سلسلةً نصّية مُنسّقة جيدًا ومنتهية بالمحرف الفارغ (null-terminated). لاحظ أنّ ‎&s[0‎]‎ ستكون مُنسّقة حتى لو كانت s فارغة، بينما تكون ‎&s.front()‎ غير مُحدّدة إن كانت ‎s‎ فارغة.

الإصدار ≥ C++‎ 17 في المثال التالي، تشير كل من cstr و data إلى "This is a string.\0":

std::string str("This is a string.");
const char* cstr = str.c_str(); 
const char* data = str.data(); 
std::string str("This is a string.");

انسخ محتويات str لفك lifetime من كائن std::string:

std::unique_ptr<char []> cstr = std::make_unique<char[]>(str.size() + 1);

// حل بديل للسطر أعلاه، غير محصن من الاعتراضات.
// char* cstr_unsafe = new char[str.size() + 1];

std::copy(str.data(), str.data() + str.size(), cstr);
cstr[str.size()] = '\0';        //  ينبغي إضافة سلسلة نصّية منتهية بحرف فارغ

// delete[] cstr_unsafe;
std::cout << cstr.get();

استخدام الصنف std::string_view

الإصدار ≥ C++‎ 17

قدّمت C++‎ 17 الصنف ‎std::string_view‎، وهو ببساطة مدىً غير مالك (non-owning range) من المحارف الثابتة (‎const char‎)، والقابلة للتنفيذ إمّا على هيئة زوج من المؤشّرات، أو مؤشّر وطول (length)، وهو نوع معاملات أفضل للدوالّ التي تتطلب سلاسل نصّية غير قابلة للتعديل.

وكان قبل الإصدار C++‎ 17 ثلاثة خيارات لفعل هذا: الأول: وسيط واحد، قد يقوم بالتخصيص إن لم تكن بيانات المستدعي في سلسلة نصية مثل سلسلة نصية مجردة أو <vector<char:

void foo(std::string const& s);

الثاني: وسيطان، يجب أن يمررهما في كل مكان.

void foo(const char* s, size_t len);

والثالث: وسيط واحد، لكن يجب أن يستدعي ()strlen.

void foo(const char* s);

يستطيع المستدعي تمرير مزود بيانات محرفية لكن سيكون على ()foo أن يتواجد في ترويسة.

template < class StringT >
    void foo(StringT const& s);

يمكن استبدال كلّ ما في المثال السابق بالشيفرة التالية، ومزاياها أنها بوسيط واحد، مع ربط أقوى، وبدون نُسخ بغض النظر عن كيفية تخزين المستدعي للبيانات.

void foo(std::string_view s);

لاحظ أنّ std::string_view لا يمكنها تعديل البيانات الأساسية (underlying data) الخاصّة بها.

‎string_view‎ مفيدة في حال أردت تجنّب عمليات النسخ غير الضرورية، كما تقدم مجموعة من وظائف السلاسل النصّية، رغم أنّ سلوك بعض الدوالّ قد يختلف، انظر المثال التالي لسلسلة نصية طويلة بدون داعي:

std::string str = "lllloooonnnngggg sssstttrrriiinnnggg"; // سلسلة نصّية طويلة

استخدام string::subsr سيعيد سلسلة نصية جديدة، وهذا مكلف إن كانت السلسلة طويلة، انظر:

std::cout << str.substr(15, 10) << '\n';

وعليه فلا نحبذ هذا الأسلوب، ومن ناحية أخرى فلن تنشئ الطريقة الصحيحة هنا أي نسخ إضافية، انظر:

std::string_view view = str;

وستعيد string_view::substr سلسلة string_view جديدة:

std::cout << view.substr(15, 10) << '\n';

التحويل إلى std::wstring

تُمثَّل تسلسلات المحارف في C++‎ عبر تخصيص الصنف ‎std::basic_string‎ بنوع محرفي أصلي (native)، والمجموعتان الرئيسيتان المُعرّفتان في المكتبة القياسية هما ‎std::string‎ و ‎std::wstring‎:

• ‎std::string‎ هي سلسلة مبنية بعناصر من نوع char
• ‎std::wstring‎ مبنية بعناصر من نوع wchar_t

استخدم لأجل التحويل بين النوعين، ‎wstring_convert‎:

#include <string>
#include <codecvt>
#include <locale>

std::string input_str = "this is a -string-, which is a sequence based on the -char- type.";
std::wstring input_wstr = L"this is a -wide- string, which is based on the -wchar_t- type.";
// التحويل
std::wstring str_turned_to_wstr = std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(input_str);
std::string wstr_turned_to_str = std::wstring_convert<std::codecvt_utf8<wchar_t>>().to_bytes(input_wstr);

لتحسين قابلية الاستخدام وسهولة القراءة، عرِّف دوالًا لتنفيذ عملية التحويل:

#include <string>
#include <codecvt>
#include <locale>

using convert_t = std::codecvt_utf8 < wchar_t > ;
std::wstring_convert < convert_t, wchar_t > strconverter;

std::string to_string(std::wstring wstr) {
    return strconverter.to_bytes(wstr);
}

std::wstring to_wstring(std::string str) {
    return strconverter.from_bytes(str);
}

مثال تطبيقي:

std::wstring a_wide_string = to_wstring("Hello World!");

هذا أفضل وأوضح بكثير من السطر التالي:

td::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes("HelloWorld!")‎‎‎

لاحظ أنّ ‎char‎ و ‎wchar_t‎ لا تقتضيان الترميز (encoding) ولا تُعطيان أيّ إشارة عن الحجم بالبايتات، على سبيل المثال، تُستخدم ‎wchar_t‎ عادة كنوع بيانات ثنائي البايت، وعادة ما تحتوي على بيانات مُرمّزة بترميز UTF-16 في ويندوز (أو UCS-2 في الإصدارات السابقة لنظام ويندوز 2000) أو كنوع بيانات رباعي البايت مُرمّز باستخدام الترميز UTF-32 في لينكس.

هذا على النقيض من الأنواع الحديثة ‎char16_t‎ و ‎char32_t‎، والتي جاءت في الإصدار C++‎ 11، إذ هي كبيرة بما يكفي لاحتواء أيّ محرف من UTF16 أو UTF32 على الترتيب.

الموازنة المعجمية

يمكن موازنة سلسلتين نصّيتين معجميًا باستخدام المعاملات ‎==‎ و ‎!=‎ و ‎<‎ و ‎<=‎ و ‎>‎ و ‎>=‎:

std::string str1 = "Foo";
std::string str2 = "Bar";

assert(!(str1 < str2));
assert(str > str2);
assert(!(str1 <= str2));
assert(str1 >= str2);
assert(!(str1 == str2));
assert(str1 != str2);

تستخدِم كل هذه الدوالّ التابع ‎std::string::compare()‎ لإجراء المقارنات وإعادة القيمة البوليانية المناسبة.

وفيما يلي شرح عامّ لمعَاملات الموازنة:

• المُعامل ‎==‎

إذا كانت ‎str1.length() == str2.length()‎، وتطابقت أزواج المحارف (character pairs)، فسيعيد المُعاملُ القيمةَ ‎true‎، وإلا فسَيعيد ‎false‎.

• المُعامل ‎!=‎

إذا كانت ‎str1.length() != str2.length()‎ أو لم تتطابق أزواج المحارف، فسَيعيد المُعامل القيمة ‎true‎، وإلا فسيعيد ‎false‎.

• المُعامل ‎<‎ أو المُعامل ‎>‎

 يبحثان عن أول زوج غير متطابق من المحارف، ويقارن بينهما ثم يعيد النتيجة البوليانية تبعًا لنتيجَة الموازنة.

• المُعامل ‎<=‎ أو المُعامل ‎>=‎

 يبحث عن أول زوج غير متطابق من المحارف، ويقارن بينهما ثم يعيد النتيجة البوليانية.

ملاحظة: يشير مصطلح زوج المحارف (character pair) إلى المحارف المتقابلة في كلا السلسلتين، أي الحرفين الذين يوجَدين في نفس الموضع من السلسلتين النّصّيتين. مثلًا، لنفترض أنّ لدينا سلسلتين نصّيتين ‎str1‎ و ‎str2‎، وطولاهما ‎n‎ و ‎m‎ على التوالي، في هذه الحالة ستكون أزواج المحارف في كلتَي السلسلتين النصّيتين هي الأزواج ‎str1‎ و ‎str2‎ حيث i = 0, 1, 2, …, max(n,m)‎. في حال عدم وجود حرف يقابل الفهرس i، أي عندما يكون i أكبر من أو يساوي ‎n‎ أو ‎m‎، فسيتم اعتبارُه القيمةَ الأصغر.

فيما يلي مثال على استخدام ‎<‎:

std::string str1 = "Barr";
std::string str2 = "Bar";

assert(str2 < str1);

خطوات الموازنة هي كالتالي:

1. موازنة الحرفين الأوّلين، ‎'B' == 'B'‎ - ثم متابعة.
2. موازنة بين الحرفين الثانيين، ‎'a' == 'a'‎ - ثم متابعة.
3. موازنة بين الحرفين الثّالثين، ‎'r' == 'r'‎ - ثم متابعة.
4. استُنفِذ نطاق ‎str2‎ الآن، في حين أنّ نطاق ‎str1‎ ما يزال فيه محارف زائدة. وبالتالي يكون لدينا: ‎str2 < str1‎.

تقليم المحارف في بداية أو نهاية السلسلة النصية

يتطلب هذا المثال الترويسات و و .

الإصدار ≥ C++‎ 11

تقليم (trim) تسلسل أو سلسلة نصّية يعني إزالة جميع العناصر الأولى أو الأخيرة التي تحقق شرطًا معينًا، ونقلّم أولًا العناصر الأخيرة لأنها لا تتطلب تحريك أيّ عنصر، ثم نقلّم العناصر الأولى.

لاحظ أنّ التعميمات أدناه تعمل مع جميع أنواع السلاسل النصّية الأساسية ‎std::basic_string‎، مثل ‎std::string‎ و ‎std::wstring‎، وأيضًا على الحاويات مثل ‎std::vector‎ و ‎std::list‎.

template < typename Sequence, // list أو  vector أي سلسلة نصّية أساسية، مثل     
    typename Pred > // شرط
    Sequence& trim(Sequence& seq, Pred pred) {
        return trim_start(trim_end(seq, pred), pred);
    }

يعتمد تقليم العناصر الأخيرة على إيجاد العنصر الأخير غير المطابق للشّرط، وبدء عملية المحو من هناك:

template < typename Sequence, typename Pred >
    Sequence & trim_end(Sequence & seq, Pred pred) {
        auto last = std::find_if_not(seq.rbegin(),
            seq.rend(),
            pred);
        seq.erase(last.base(), seq.end());
        return seq;
    }

أمّا تقليم العناصر الأولية، فيعتمد على تحديد العنصر الأوّل الذي لا يحقّق الشرط وبدء عملية المحو من بداية السلسلة وحتى هناك:

template < typename Sequence, typename Pred >
    Sequence & trim_start(Sequence & seq, Pred pred) {
        auto first = std::find_if_not(seq.begin(),
            seq.end(),
            pred);
        seq.erase(seq.begin(), first);
        return seq;
    }

استخدم الدالّة ‎std::isspace()‎ كشرط إذا أردت تقليم المسافات الفارغة في سلسلة نصّية :

std::string& trim(std::string& str, const std::locale& loc = std::locale()) {
return trim(str, [&loc](const char c){ return std::isspace(c, loc); });
}

std::string& trim_start(std::string& str, const std::locale& loc = std::locale()) {
return trim_start(str, [&loc](const char c){ return std::isspace(c, loc); });
}

std::string& trim_end(std::string& str, const std::locale& loc = std::locale()) {
return trim_end(str, [&loc](const char c){ return std::isspace(c, loc); });
}

وبالمثل، يمكننا استخدام الدالّة ‎std::iswspace()‎ مع السلاسل النصّية ‎std::wstring‎.

إذا كنت ترغب في إنشاء تسلسل جديد عبر إنشاء نسخة مُقلَّمة، فيمكنك استخدام دالّة منفصلة على النحو التالي:

template < typename Sequence, typename Pred >
    Sequence trim_copy(Sequence seq, Pred pred) { // بالقيمة seq  تمرير
        trim(seq, pred);
        return seq;
    }

استبدال السلاسل الصّية

الاستبدال بالموضع

استخدم التابع ‎replace‎ الخاص بالصنف ‎std::string‎ لاستبدال جزء من سلسلة نصّية. أيضًا، التابع ‎replace‎ له الكثير من التحميلات الزائدة (overloads) المفيدة:

// عرِّف سلسلة نصّية
std::string str = "Hello foo, bar and world!";
std::string alternate = "Hello foobar";

//1)
str.replace(6, 3, "bar"); //"Hello bar, bar and world!"

//2)
str.replace(str.begin() + 6, str.end(), "nobody!"); //"Hello nobody!"

//3)
str.replace(19, 5, alternate, 6, 6); //"Hello foo, bar and foobar!"

الإصدار ≥ C++‎ 14

//4)
str.replace(19, 5, alternate, 6); //"Hello foo, bar and foobar!"

//5)
str.replace(str.begin(), str.begin() + 5, str.begin() + 6, str.begin() + 9);
//"foo foo, bar and world!"

//6)
str.replace(0, 5, 3, 'z'); //"zzz foo, bar and world!"

//7)
str.replace(str.begin() + 6, str.begin() + 9, 3, 'x'); //"Hello xxx, bar and world!"

الإصدار ≥ C++‎ 11

//8)
str.replace(str.begin(), str.begin() + 5, { 'x', 'y', 'z' }); //"xyz foo, bar and world!"

استبدال سلسلة نصّية بأخرى

استبدل بالظهور الأول فقط للسلسلة النصّية ‎with‎ السلسلة ‎replace‎ في ‎str‎:

std::string replaceString(std::string str,
    const std::string& replace,
        const std::string& with) {
    std::size_t pos = str.find(replace);
    if (pos != std::string::npos)
        str.replace(pos, replace.length(), with);
    return str;
}

استبدال السّلسلة النصّية ‎with‎ بالسلسلة ‎replace‎ أينما ظهرت في ‎str‎:

std::string replaceStringAll(std::string str,
    const std::string& replace,
        const std::string& with) {
    if (!replace.empty()) {
        std::size_t pos = 0;
        while ((pos = str.find(replace, pos)) != std::string::npos) {
            str.replace(pos, replace.length(), with);
            pos += with.length();
        }
    }
    return str;
}

التحويل إلى سلسلة نصية

استخدم std::ostringstream لتحويل أيّ نوع قابل للإجراء (streamable type) إلى تمثيله النصي -أي إلى سلسلة نصّية-، عن طريق إدراج الكائن المُراد تحويله في كائن ‎std::ostringstream‎ (عبر معامل إدراج المجرى ‎<<‎)، ثم تحويل ‎std::ostringstream‎ بأكملها إلى سلسلة نصّية.

مثلًا، بالنسبة للأعداد الصحيحة ‎int‎:

#include <sstream>

int main() {
    int val = 4;
    std::ostringstream str;
    str << val;
    std::string converted = str.str();
    return 0;
}

اكتب دالّة التحويل الخاصة بك:

template < class T >
    std::string toString(const T & x) {
        std::ostringstream ss;
        ss << x;
        return ss.str();
    }

هذه الدالّة ستعمل بنجاح، لكنّ أداءها أقلّ كفاءة. يمكن أن تنفذ الأصناف المُعرَّفة من قبل المستخدم عاملَ إدراج المجرى، انظر المثال التالي حيث نكتب تمثيلًا نصيًا ل a في out:

std::ostream operator << (std::ostream & out,
    const A & a) {
    return out;
}

الإصدار ≥ C++‎ 11

بصرف النظر عن مجاري التدفق، أصبح ممكنًا منذ الإصدار C++‎ 11 أن نستخدم الدالّة ‎std::to_string‎ (و ‎std::to_wstring‎) والتي حُمِّلت تحميلًا زائدًا في جميع الأنواع الأساسية، وصارت تعيد تمثيلًا نصيًّا للمعامل المُمرّر إليها.

std::string s = to_string(0x12f3); // "4851" القيمة s بعد هذا ستحتوي

التقسيم (Splitting)

استخدم ‎std::string::substr‎ لتقسِيم السلاسل النصّية. هناك نوعان من هذا التابع، يأخذ الأول موضع البداية، والذي ستبدأ منه السلسلة النصّية الفرعية (substring) المُعادة. يجب أن يكون موضع البداية جزءًا من النطاق (0, str.length()]‎:

std::string str = "Hello foo, bar and world!";
std::string newstr = str.substr(11); // "bar and world!"

فيما يأخذ التابع الثاني موضع البداية والطول الإجمالي للسّلسلة النصّية الفرعية الجديدة. ولن تتجاوز السلسلة النصّية الفرعية نهاية السلسلة النصّية المصدرية مهما كان الطول المُمرَّر:

std::string str = "Hello foo, bar and world!";
std::string newstr = str.substr(15, 3); // "and"

لاحظ أنّك تستطيع استدعاء ‎substr‎ بدون أي وسائط، وفي هذه الحالة ستُعاد نسخة مضبوطة من السلسلة النصية:

std::string str = "Hello foo, bar and world!";
std::string newstr = str.substr(); // "Hello foo, bar and world!"

الوصول إلى محرف من السلسلة النصية

هناك عدة طرق لاستِخراج الحروف من السلاسل النصّية، ولكلّ منها خصوصياتها.

std::string str("Hello world!");

operator‎

يعيد مرجعًا إلى الحرف الموجود عند الفهرس n. لا يتحقّق المُعامل td::string::operator[]‎ من حدود السلسلة النصّية، ولا يرفع اعتراضًا (exception) في حال تجاوزها، لذلك فالمُستدعي هو المسؤول عن التحقق من أنّ الفهرس يقع في حدود السلسلة النصّية:

char c = str[6]; // 'w'

at(n)‎

يعيد مرجعًا إلى الحرف الموجود عند الفهرس n. يتحقق المُعامل ‎std::string::at‎ من الحدود، ويرفع اعتراض ‎std::out_of_range‎ إذا لم يكن الفهرس ضمن حدود السلسلة النصّية:

char c = str.at(7); // 'o'

الإصدار ≥ C++‎ 11

ملاحظة: في كلا المثالين أعلاه، سيكون السّلوك غير محدد في حال كانت السلسلة النصية فارغة.

front()‎

يعيد مرجعًا إلى الحرف الأول:

char c = str.front(); // 'H'

back()‎

يعيد مرجعًا إلى الحرف الأخير:

char c = str.back(); // '!'

التحقق من كون سلسلة نصية سابقة (prefix) لسلسلة أخرى

الإصدار ≥ C++‎ 14

في الإصدار C++‎ 14، يمكن إنجاز ذلك بسهولة عبر ‎std::mismatch‎، والذي يُعيد الزوج الأوّل غير المتطابق من النطاقين:

std::string prefix = "foo";
std::string string = "foobar";
bool isPrefix = std::mismatch(prefix.begin(), prefix.end(),
string.begin(), string.end()).first == prefix.end();

قبل الإصدار C++‎ 14، كان هناك ما يُسمّى إصدار النطاق ونصف (range-and-a-half version) من التابع ‎mismatch()‎، ولكنه لم يكن آمنًا في حال كانت السلسلة النصّية الثانية أقصر من الأولى.

الإصدار < C++‎ 14

++‎>

لا زال بإمكاننا استخدام إصدار النطاق ونصف من التابع ‎std::mismatch()‎، لكن سيكون عليك التحقّق أولًا من أنّ السلسلة النصّية الأولى أقصر من الثانية أو تعادلها:

bool isPrefix = prefix.size() <= string.size() &&
std::mismatch(prefix.begin(), prefix.end(),
string.begin(), string.end()).first == prefix.end();

الإصدار ≥ C++‎ 17

يمكننا كتابة الموازنة التي نريدها مباشرة مع ‎std::string_view‎، دون الحاجة إلى القلق بشأن الحِمل الزائد في الذاكرة (allocation overhead) أو إنشاء النُّسخ:

bool isPrefix(std::string_view prefix, std::string_view full)
{
return prefix == full.substr(0, prefix.size());
}

التكرار على المحارف

الإصدار ≥ C++‎ 17

تدعم السلاسل النصّية المُكرّرات، وعليه تستطيع استخدام حلقة نطاقية (ranged based loop) للتكرار على المحارف:

std::string str = "Hello World!";
for (auto c: str)
    std::cout << c;

يمكنك أيضًا استخدام حلقة ‎for‎ "تقليدية" للتكرار على المحارف:

std::string str = "Hello World!";
for (std::size_t i = 0; i < str.length(); ++i)
    std::cout << str[i];

التحويل إلى الأعداد الصحيحة أو العَشرية

يمكن تحويل سلسلة نصّية تحتوي على عدد إلى نوع عددي صحيح أو عشري باستخدام دوالّ التحويل.

ملاحظة: تتوقف جميع هذه الدوالّ عن تحليل السلسلة النصّية المُدخلة بمجرد أن تصادف محرفًا غير رقمي. مثلاً، ستُحوّل السلسلة النصّية ‎"123abc"‎ إلى 123.

تحوّل مجموعة الدوالّ ‎std::ato*‎ السلاسل النصّية من نمط لغة C (مصفوفات المحارف) إلى أنواع عددية صحيحة أو عشرية:

std::string ten = "10";
double num1 = std::atof(ten.c_str());
int num2 = std::atoi(ten.c_str());
long num3 = std::atol(ten.c_str());

الإصدار ≥ C++‎ 11

long long num4 = std::atoll(ten.c_str());

إلا أنّه يفضَّل تجنّب استخدام هذه الدوالّ لأنها تُعيد ‎0‎ في حال فشلت في تحليل السلسلة النصّية. وهذا سيء لأنّ القيمة ‎0‎ قد تُفسَّر على أنّها نتيجة عددية صالحة. مثلًا، إن كانت السلسلة النصية المُدخلة هي "0"، فسيكون من المستحيل تحديد ما إذا كان التحويل قد فشل أم لا بغضّ النظر عن النتيجة.

وتحوّل الدوالّ الحديثة ‎std::sto*‎ السلاسل النصّية إلى أعداد صحيحة أو عشرية، وتطلق استثناءً في حال فشلت في تحليل السلسلة النصية. استخدم هذه الدّوال كلما أمكن:

الإصدار ≥ C++‎ 11

std::string ten = "10";
int num1 = std::stoi(ten);
long num2 = std::stol(ten);
long long num3 = std::stoll(ten);

float num4 = std::stof(ten);
double num5 = std::stod(ten);
long double num6 = std::stold(ten);

كذلك، فإنّ هذه الدوالّ يمكنها أن تتعامل أيضًا مع السلاسل النصّية الثُمانية (octal) والست عشرية (hex)، وذلك على عكس دوالّ ‎std::ato*‎. والمعامل الثاني هو مؤشّر يشير إلى أوّل حرف غير مُحوَّل في السلسلة النصية المُدخَلَة، أمّا المعامل الثالث فيمثّل الأساس الرقمي (base) الذي يجب استخدامه. يُستخدَم الحرف ‎0‎ للرصد التلقائي للأعداد الثُمانية (تبدأ بـ ‎0‎) والست عشرية (تبدأ بـ ‎0x‎ أو ‎0X‎)، أما القيم الأخرى فتمثّل الأساس الذي يجب استخدامه.

std::string ten = "10";
std::string ten_octal = "12";
std::string ten_hex = "0xA";

int num1 = std::stoi(ten, 0, 2); // 2
int num2 = std::stoi(ten_octal, 0, 8); // 10
long num3 = std::stol(ten_hex, 0, 16); // 10
long num4 = std::stol(ten_hex); // 0
long num5 = std::stol(ten_hex, 0, 0); // 0x تعيد 10 لأنها رصدت

ضم السلاسل النصّية

يمكنك ضمّ (concatenate) السلاسل النصّية باستخدام المُعاملين المُحمَّلين تحميلًا زائدًا ‎+‎ و ‎+=‎.

استخدام المُعامل ‎+‎:

std::string hello = "Hello";
std::string world = "world";
std::string helloworld = hello + world; // "Helloworld"

استخدام المُعامل ‎+=‎:

std::string hello = "Hello";
std::string world = "world";
hello += world; // "Helloworld"

يمكنك أيضًا ضمّ السلاسل النصّية من نمط لغة C، بما في ذلك السلاسل النصّية المجردة:

std::string hello = "Hello";
std::string world = "world";
const char *comma = ", ";
std::string newhelloworld = hello + comma + world + "!"; // "Hello, world!"

يمكنك أيضًا استخدام ‎push_back()‎ لإضافة حرف واحد إلى السلسلة النصية:

std::string s = "a, b, ";
s.push_back('c'); // "a, b, c"

لدينا يوجد أيضًا تابع ‎append()‎، والذي يشبه إلى حد كبير ‎+=‎:

std::string app = "test and ";
app.append("test"); // "test and test"

التحويل بين ترميزات المحارف

التحويل بين الترميزات (encodings) أمر سهل في C++‎ 11، ويمكن لمعظم المصرّفات إنجازه بطريقة مستقلّة عن المنصة (cross-platform) عبر الترويستين و .

#include <iostream>
#include <codecvt>
#include <locale>
#include <string>

using namespace std;
int main() {
    // wstring  و utf8 يحول بين سلاسل
    wstring_convert < codecvt_utf8_utf16 < wchar_t >> wchar_to_utf8;
    // utf16 وسلاسل utf8 يحول بين سلاسل
    wstring_convert < codecvt_utf8_utf16 < char16_t > , char16_t > utf16_to_utf8;

    wstring wstr = L"foobar";
    string utf8str = wchar_to_utf8.to_bytes(wstr);
    wstring wstr2 = wchar_to_utf8.from_bytes(utf8str);

    wcout << wstr << endl;
    cout << utf8str << endl;
    wcout << wstr2 << endl;

    u16string u16str = u"foobar";
    string utf8str2 = utf16_to_utf8.to_bytes(u16str);
    u16string u16str2 = utf16_to_utf8.from_bytes(utf8str2);

    return 0;
}

لاحظ أنّ Visual Studio 2015 يدعم مثل هذه التحويلات، ولكن بسبب خلل موجود في مكتبتها، فينبغي استخدام قالب مختلف لـ ‎wstring_convert‎ عند التعامل مع الترميز ‎char16_t‎:

using utf16_char = unsigned short;
wstring_convert<codecvt_utf8_utf16<utf16_char>, utf16_char> conv_utf8_utf16;
void strings::utf16_to_utf8(const std::u16string& utf16, std::string& utf8)
{
std::basic_string<utf16_char> tmp;
tmp.resize(utf16.length());
std::copy(utf16.begin(), utf16.end(), tmp.begin());
utf8 = conv_utf8_utf16.to_bytes(tmp);
}

البحث عن محرف أو أكثر في السلسلة النصية

استخدام التابع ‎std::string::find‎لإيجاد حرف أو سلسلة نصّية أخرى، والذي يعيد موضع الحرف الأوّل من التطابق الأوّل. أما إن لم يُعثر على أيّ تطابق، فستُعاد القيمة ‎std::string::npos‎

std::string str = "Curiosity killed the cat";
auto it = str.find("cat");
if (it != std::string::npos)
std::cout << "Found at position: " << it << '\n';
else
std::cout << "Not found!\n";

ستكون النتيجة 21.

تُوسَّع فرص البحث بالدوال التالية:

find_first_of     // إيجاد أول ظهور للمحارف
find_first_not_of // إيجاد أول غياب للمحارف
find_last_of      // إيجارد آخر ظهور للمحارف
find_last_not_of  // إيجاد آخر غياب للمحارف

تتيح لك لك هذه الدوالّ أن تبحث عن المحارف من نهاية السلسلة النصّية، وكذلك البحث عن الحالات السلبية (أي المحارف غير الموجودة في السلسلة). انظر المثال التالي:

std::string str = "dog dog cat cat";
std::cout << "Found at position: " << str.find_last_of("gzx") << '\n';

ستكون النتيجة 6.

ملاحظة: لا تبحث الدوالّ المذكورة أعلاه عن السلاسل النصّية الفرعية (substrings)، بل عن المحارف الموجودة في سلسلة البحث، ففي المثال أعلاه عُثِر على الظهور الأخير لـ ‎'g'‎ في الموضع ‎6‎ بينما لم يُعثر على المحارف الأخرى.

هذا الدرس جزء من سلسلة مقالات عن C++‎.

ترجمة -بتصرّف- للفصل Chapter 47: std::string من كتاب C++ Notes for Professionals

مثال بسيط

يحتوي المثال التالي على شيفرة يُراد تقسيمها إلى عدّة ملفّات مصدرية، سننظر الآن في كل ملف على حدة:

الملفات المصدرية

• my_function.h

في هذا الملف، لاحظ أن الترويسة التالية تحتوي على تصريح للدالة فقط، ولا تعرِّف دوال الترويسة تطبيقات للتصريحات إلا إن وجب معالجة الشيفرة أكثر أثناء التصريف، كما هو الحال في القوالب. وعادة ما تحتوي ملفات الترويسة على واقيات معالج مسبق (Preprocessor Guards) حتى لا تضاف نفس الترويسة مرتين. ويُنفَّذ الواقي بالتحقق من كون المفتاح الرمزي (Token) الفريد للمعالج المسبق معرَّفًا أم لا، ولا تُضمَّن الترويسة إلا إن كانت غير مضمَّنة من قبل. سيتم التعرف على كل من global_value و ()my_function على أنهما نفس البُنية إن أضيفت هذه الترويسة من قبَل عدة ملفات.

// my_function.h
#ifndef MY_FUNCTION_H
#define MY_FUNCTION_H

const int global_value = 42;
int my_function();
#endif // MY_FUNCTION_H

• my_function.cpp

في هذا الملف، لاحظ أن الملف المصدري المقابل للترويسة يدرِج الواجهة المعرَّفة في الترويسة، كي ينتبه المصرِّف إلى ما ينفذه الملف المصدري. ويتطلب الملف المصدري في هذا الحالة معرفة الثابت العام global_value المعرَّف في ملف my_function.h الذي استعرضناه قبل قليل، ولن يصرَّف هذا الملف المصدري بدون الترويسة.

// my_function.cpp
#include "my_function.h" // or #include "my_function.hpp"

int my_function() {
    return global_value; // 42;
}

• main.cpp

تُدرج ملفّات الترويسة بعد ذلك في الملفّات المصدرية الأخرى التي ترغب في استخدام الوظائف المُعرّفة في واجهة الترويسة، دون الحاجة إلى معرفة تفاصيل تنفيذها، مما يساعد على اختزال الشيفرة. يستخدم البرنامج التالي الترويسة ‎my_function.h‎:

// main.cpp
#include <iostream>       // ترويسة مكتبة قياسية

#include "my_function.h"  // ترويسة خاصة

int main(int argc, char** argv) {
    std::cout << my_function() << std::endl;
    return 0;
}

عملية التصريف (The Compilation Process)

تكون ملفّات الترويسة غالبًا جزءًا من عملية التصريف، لذا يحدث ما يلي خلال عملية التصريف في العادةً:

على افتراض أنّ ملفّ الترويسة وملفّّ الشيفرة المصدرية موجودان في نفس المجلّد، فيمكن تصريف البرنامج عبر تنفيذ الأوامر التالية:

g++ - c my_function.cpp 
g++main.cpp my_function.o

السطر الأولُ في الشيفرة السابقة يصرِّف الملفَّ المصدري my_function.cpp إلى my_function.o، ويربط السطر الثاني ملفَّ الكائن الذي يتحوي تنفيذ ()int my_function إلى نسخة الكائن المصرَّفة من main.cpp ثم ينتج النسخة التنفيذية النهائية a.out.

بالمقابل، إذا رغبت في تصريف ‎main.cpp‎ إلى ملفّ كائنٍ أولًا، ثم ربط ملفّات التعليمات المصرّفة في النهاية، فيمكنك ذلك عبر الشيفرة التالية:

g++ -c my_function.cpp
g++ -c main.cpp

g++ main.o my_function.o

القوالب في ملفات الترويسات

تتطلّب القوالب إنشاء الشيفرة وقت التصريف: على سبيل المثال، تُحوّل دالّة مُقولَبة (templated function) إلى عدة دوالّ مختلفة بمجرد جعل الدالّة المُقَولبة معامِلًا (parameter) عبر استخدامها في الشيفرة المصدرية.

هذا يعني أنّه لا يمكن تفويض الدوالّ والتوابع وتعريفات الأصناف في القوالب إلى ملفّ مصدري آخر، ذلك أنّ أيّ شيفرة تستخدم بنية مُقولَبَة تحتاج إلى أن تَطَّلِع على تعريف تلك البنية لإنشاء الشيفرة المشتقّة. وعليه يجب أن تحتوي الشيفرة المُقولبَة على تعريفها في حال وُضِعت في الترويسات. هذا مثال على ذلك:

// templated_function.h

template < typename T >
    T* null_T_pointer() {
        T* type_point = NULL; // وما بعدها C++11 في NULL بدلا من nullptr أو 
        return type_point;
    }

معالجة التاريخ والوقت باستخدام الترويسة <chrono>

قياس الوقت باستخدام <chrono>

يمكن استخدام ‎system_clock‎ لقيَاس الوقت المنقضي منذ مرحلة معيّنة من تنفيذ البرنامج.

الإصدار = C++‎ 11

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    auto start = std::chrono::system_clock::now(); { // الشيفرة المراد اختبارها
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    auto end = std::chrono::system_clock::now();
    std::chrono::duration < double > elapsed = end - start;
    std::cout << "Elapsed time: " << elapsed.count() << "s";
}

استخدمنا في هذا المثال ‎sleep_for‎ لجعل الخيط النشط ينام (sleep) لفترة زمنية مُقاسة بالثواني std::chrono::seconds.

حساب عدد الأيام بين تاريخين

يوضّح هذا المثال كيفية حساب عدد الأيّام بين تاريخين، ويُحدَّد التاريخ بالصيغة سنة/شهر/يوم (year/month/day)، بالإضافة إلى ساعة/دقيقة/ثانية (hour/minute/second).

يحسب البرنامج التالي المستوحى من موقع cppreference عدد الأيام منذ عام 2000. سننشئ بُنية std::tm من التاريخ الخام على النحو التالي:

• year يجب أن تكون 1900 أو أكبر.
• month من يناير (1 - 12).
• day اليوم من الشهر (1 - 31).
• minutes الدقائق بعد الساعة (0 - 59).
• seconds الثواني بعد الدقيقة (0 - 61)، و (0 - 60) منذ C++ 11.

#include <iostream>
#include <string>
#include <chrono>
#include <ctime>

std::tm CreateTmStruct(int year, int month, int day, int hour, int minutes, int seconds) {
    struct tm tm_ret = {
        0
    };

    tm_ret.tm_sec = seconds;
    tm_ret.tm_min = minutes;
    tm_ret.tm_hour = hour;
    tm_ret.tm_mday = day;
    tm_ret.tm_mon = month - 1;
    tm_ret.tm_year = year - 1900;

    return tm_ret;
}
int get_days_in_year(int year) {

    using namespace std;
    using namespace std::chrono;

    // نريد أن تكون النتيجة بالأيام
    typedef duration < int, ratio_multiply < hours::period, ratio < 24 > > ::type > days;

    // بداية الوقت
    std::tm tm_start = CreateTmStruct(year, 1, 1, 0, 0, 0);
    auto tms = system_clock::from_time_t(std::mktime( & tm_start));

    // نهاية الوقت
    std::tm tm_end = CreateTmStruct(year + 1, 1, 1, 0, 0, 0);
    auto tme = system_clock::from_time_t(std::mktime( & tm_end));

    // حساب الوقت الذي مرّ بين التاريخين
    auto diff_in_days = std::chrono::duration_cast < days > (tme - tms);

    return diff_in_days.count();
}
int main() {
    for (int year = 2000; year <= 2016; ++year)
        std::cout << "There are " << get_days_in_year(year) << " days in " << year << "\n";
}

هذا الدرس جزء من سلسلة دروس عن C++‎.

ترجمة -بتصرّف- للفصل Chapter 45: Header Files والفصل Chapter 66: Date and time using header من كتاب C++ Notes for Professionals

تُستخدم فضاءات الأسماء (Namespaces) لمنع التضارب الذي قد يحدث عند استخدام عدّة مكتبات في نفس البرنامج، وفضاء الاسم سابقةٌ (prefix) تعريفية للدوالّ والأصناف والأنواع وغيرها.

ما هي فضاءات الاسم؟

فضاء الاسم في لغة ++C هو مجموعة من كيانات C++‎ سواءً كانت دوالًا أو أصنافًا أو متغيرات، وتُسبق أسماءها باسم "فضاء الاسم"، وعند كتابة شيفرة ضمن فضاء الاسم فلا يلزم إسباق الكيانات المسمّاة التي تنتمي إلى فضاء الاسم باسم ذلك الفضاء، أمّا الكيانات الموجودة خارجه فيجب أن تُؤهّل أسماؤها (أي تُسبق باسم "فضاء الاسم").

الاسم المؤهّل يأخذ الشكل التالي ‎<namespace>::<entity>‎. انظر الشيفرة التالية:

namespace Example {
    const int test = 5;
    const int test2 = test + 12;        // `Example` تعمل داخل فضاء الاسم
}
const int test3 = test + 3;             // غير موجودة خارج فضاء الاسم `test` خطأ، لأن
const int test3 = Example::test + 3;    // هذا يعمل لأنّ المتغير مؤهل

فضاءات الاسم مفيدة لتجميع التعريفات المرتبطة ببعضها معًا، ويمكن تشبيهها بمراكز التسوف التي تُقسّم إلى عدة متاجر يبيع كل منها سلعًا من صنف محدد، فقد يكون أحد المتاجر متخصصًأ في الإلكترونيات بينما يكون مجال الآخر في بيع الأحذية.

هذا التصنيف المنطقي لأنواع المتاجر يساعد المتسوّقين على العثور على السلع التي يبحثون عنها. وبالمثل فإن فضاءات الاسم تساعد مبرمجي C++‎ في العثور على الدوالّ والأصناف والمتغيرات التي يبحثون عنها من خلال تنظيمها بطريقة منطقية. مثلًا:

namespace Electronics {
    int TotalStock;
    class Headphones {
        // (color, brand, model number) وصف السماعات
    };
    class Television {
        // (color, brand, model number) وصف التلفاز
    };
}
namespace Shoes {
    int TotalStock;
    class Sandal {
        // (color, brand, model number) وصف الصندل
    };
    class Slipper {
        // (color, brand, model number) وصف الخُف
    };
}

لدينا فضاء اسم معرّف مسبقًا وهو فضاء الاسم العام ( global namespace)، وليس لهذا الفضاء اسم، لكن يُرمَز إليه بـ ‎::‎. مثلًا:

void bar() {
    // مُعرّفة في فضاء الاسم العام
}
namespace foo {
    void bar() {
        // foo مُعرّفة في فضاء الاسم  
    }
    void barbar() {
        bar(); // foo::bar() استدعاء
        ::bar(); // المُعرّفة في فضاء الاسم العام  bar() استدعاء
    }
}

البحث القائم على الوسائط

عند استدعاء دالّة ليس لها مؤهّلُ فضاءِ اسمٍ (namespace qualifier) صريح، فإن للمصرّف الحرية في استدعاء تلك الدالّة داخل فضاء اسم ما إن وُجد أحد أنواع المعاملات الخاصّة بتلك الدالّة في هذا الفضاء، وهذا يُسمّى "البحث القائم على الوسائط" (Argument Dependent Lookup أو ADL)، انظر:

namespace Test
{
    int call(int i);
    class SomeClass {...};

    int call_too(const SomeClass & data);
}

call(5); // خطأ: اسم دالّة غير مؤهل

Test::SomeClass data;

call_too(data); // ناجح.

تفشل ‎call‎ لأنّ أنواع المعاملات الخاصة بها لا تنتمي إلى فضاء الاسم ‎Test‎، على عكس ‎call_too‎ التي تعمل بنجاح لأنّ ‎SomeClass‎ عضو في ‎Test‎، ومن ثم فإنه مؤهّل للبحث القائم على الوسائط.

ما الذي يمنع البحث القائم على الوسائط (ADL)

لا يحدث البحث القائم على الوسائط إذا كان البحث العادي غير المؤهّل (normal unqualified lookup) يجد عضوًا من صنف أو دالّة مُصرَّحة في نطاق الكتلة أو كائنًا من غير نوع الدالّة. انظر:

void foo();
namespace N {
struct X {};
void foo(X ) { std::cout << '1'; }
void qux(X ) { std::cout << '2'; }
}

struct C {
void foo() {}
void bar() {
           // لا تأخذ أي وسائط C::foo() خطأ: البحث القائم على الوسائط معطّل والدالّة
foo(N::X{}); 
}
};
void bar() {
extern void foo(); // ‫إعادة تعريف ‎::foo
 // لا تأخذ أي وسائط ::foo() خطأ: البحث القائم على الوسائط معطّل والدالّة
foo(N::X{});
}

int qux;

void baz() {
qux(N::X{}); // qux خطأ: إعلان المتغير يعطل البحث القائم على الوسائط بالنسبة لـ 
}

توسيع فضاءات الاسم

إحدى الميزات المفيدة لفضاءات الاسم ‎namespace‎ هو أنّه يمكنك توسيعها، أي إضافة أعضاء إليها.

namespace Foo {
    void bar() {}
}
// أشياء أخرى
namespace Foo {
    void bar2() {}
}

المُوجّه 'using'

كلمة using المفتاحية لها ثلاث نكهات، وعندما نجمعها مع كلمة namespace فإننا نكتب موجِّهَ using أو (Using Directive)، فإذا لم ترد أن تكتب ‎Foo::‎ قبل كلّ كيان في فضاء الاسم ‎Foo‎، فيمكنك استخدام التعبير ‎using namespace Foo;‎ لاستيراد كل ما تحتويه ‎Foo‎. انظر:

namespace Foo {
    void bar() {}
    void baz() {}
}
// Foo::bar() ينبغي استخدام
Foo::bar();
// Foo استيراد
using namespace Foo;
bar(); // جيد
baz(); // جيد

من الممكن أيضًا استيراد كيانات محدّدة في فضاء الاسم بدلاً من استيراد فضاء الاسم بأكمله:

using Foo::bar;
bar(); // جيد، تم استيراده بنجاح.
baz(); // خطأ، لم يُستورَد.

تحذير: غالبًا ما يُعدّ وضع ‎using namespace‎ في ملفات الترويسة من الممارسات السيئة لأنّ ذلك سيؤدي إلى استيراد فضاء الاسم في كلّ ملف يتضمن تلك الترويسة. ونظرًا لعدم وجود أيّ طريقة لتعطيل استيراد فضاء الاسم، فقد يؤدي ذلك إلى تلويث فضاء الاسم (أي حشو فضاء الاسم العام برموز كثيرة أو غير متوقعة)، أو قد يؤدّي إلى التضارب بين الأسماء. انظر المثال التالي لتوضيح هذا الأمر:

/***** foo.h *****/
namespace Foo {
    class C;
}
/***** bar.h *****/
namespace Bar {
    class C;
}
/***** baz.h *****/
#include "foo.h"

using namespace Foo;
/***** main.cpp *****/
#include "bar.h"

#include "baz.h"

using namespace Bar;
C c; // Foo::C و  Bar::C خطأ: تضارب بين

كما ترى، فلا يمكن استخدام الموجّه using في نطاق الصنف.

التصريح عبر using

عندما تصرّح عن كائنٍ ما باستخدام ‎using‎ فسيؤدّي ذلك إلى إدخال اسم سبق تصريحه في موضع آخر إلى النطاق الحالي.

استيراد الأسماء فرديًّا من فضاء اسم

انظر المثال التالي:

#include <iostream>
int main() {
    using std::cout;
    cout << "Hello, worlبd!\n";
}

عند استخدام ‎using‎ لإدخال الاسم ‎cout‎ من فضاء اسم ‎std‎ في نطاق دالّة ‎main‎، سنتمكن من الإشارة إلى الكائن std::cout بالاسم cout فقط.

إعادة التصريح عن أعضاء صنف أساسي لتجنّب إخفاء الأسماء

لا يُسمح بإعادة تعريف الأعضاء خلا أعضاء الصنف الأساسي عند التصريح عن أعضاء عبر using في نطاق الصنف. على سبيل المثال، ‎using std::cout‎ غير مسموح بها في نطاق الصنف.

الاسم المُعاد تصريحه كان سيُخفى غالبًا، على سبيل المثال، تشير ‎d1.foo‎ في المثال أدناه إلى ‎Derived1::foo(const char*)‎ وحسب، لذلك سيحدث خطأ في التصريف.

مسألة أنّ الدالّة ‎Base::foo(int)‎ ستُخفى ليس لها تأثير. لكن من الناحية الأخرى فإن ‎d2.foo(42)‎ صحيحة لأنّ التصريح باستخدام using يُدرِج ‎Base::foo(int)‎ في مجموعة الكيانات المُسمّاة ‎foo‎ في ‎Derived2‎. ستنتهي عملية البحث عن الأسماء بإيجاد كلا الدالّتين المُسمّاتين ‎foo‎، وبعد تحليل زيادة التحميل (overload resolution)، يُختار ‎Base::foo‎.

struct Base {
    void foo(int);
};
struct Derived1: Base {
    void foo(const char * );
};
struct Derived2: Base {
    using Base::foo;
    void foo(const char * );
};
int main() {
    Derived1 d1;
    d1.foo(42); // خطأ
    Derived2 d2;
    d2.foo(42); // صحيح
}

وراثة المُنشئات

الإصدار ≥ C++‎ 11

كحالة خاصة، يمكن أن يشير استخدام using للتصريح في نطاق الصنف إلى مُنشئات (constructors) صنف أبٍ مباشر (direct base class)، ثم تُورَّث تلك المُنشئات إلى الصنف المشتقّ، ويمكن استخدامها لتهيئة ذلك الصنف. انظر:

struct Base {
    Base(int x,
        const char * s);
};
struct Derived1: Base {
    Derived1(int x,
        const char * s): Base(x, s) {}
};
struct Derived2: Base {
    using Base::Base;
};
int main() {
    Derived1 d1(42, "Hello, world");
    Derived2 d2(42, "Hello, world");
}

في الشيفرة أعلاه، يحتوي كل من ‎Derived1‎ و ‎Derived2‎ على مُنشئات تعيد توجيه الوسائط مباشرةً إلى المُنشئ المقابل للصنف ‎Base‎. وينفّذ الصنف ‎Derived1‎ إعادة التوجيه بشكل صريح، بينما يستخدم الصنف ‎Derived2‎ ميزة توريث المُنشئات الموجودة في C++‎ 11 لفعل ذلك ضمنيًا.

إنشاء فضاءات الاسم

من السهل إنشاء فضاءات الاسم، انظر المثال التالي إذ سننشئ فضاء الاسم foo ثم نصرح عن الدالة bar فيه:

namespace Foo {
    void bar() {}
}

لاستدعاء ‎bar‎، يجب عليك تحديد فضاء الاسم أولاً، متبوعًا بعامل تحليل النطاق (scope resolution operator‏‏) وهو ‎::‎:

Foo::bar();

يُسمح بإنشاء فضاء اسمٍ داخل فضاء اسم آخر، مثلًا:

namespace A {
    namespace B {
        namespace C {
            void bar() {}
        }
    }
}

الإصدار ≥ C++‎ 17

يمكن تبسيط الشيفرة أعلاه على النحو التالي:

namespace A::B::C {
    void bar() {}
}

فضاءات الاسم غير المُسمّاة أو المجهولة

يمكن استخدام فضاء اسم غير مُسمَّى (unnamed namespace) لضمان وجود ارتباط داخلي بين الأسماء التي لا يمكن الإشارة إليها إلّا بوحدة الترجمة الحالية (translation unit)، وتُعرّف فضاءات الاسم غير المسمّاة بنفس طريقة تعريف فضاءات الاسم الأخرى، ولكن من دون اسم:

namespace {
    int foo = 42;
}

لن تكون ‎foo‎ مرئيّة إلّا في وحدة الترجمة التي تظهر فيها، ويوصى بعدم استخدام فضاءات-الاسم-غير-المُسمّاة في ملفات الترويسة (Header Files) لأنّ هذا سيعطي إصدارًا من المحتوى لكل وحدة ترجمة أُدرِج فيها، وهذا مهم جدًا خاصّة عند تعريف متغيرات-عامة-غير-ثابتة. انظر:

// foo.h
namespace {
    std::string globalString;
}

// 1.cpp
#include "foo.h" //< تولّد: unnamed_namespace{1.cpp}::globalString ...

globalString = "Initialize";

// 2.cpp
#include "foo.h" //< تولّد: unnamed_namespace{2.cpp}::globalString ...

std::cout << globalString; //< ستطبع دائما سلسلة نصية فارغة

فضاءات الاسم المضغوطة والمتشعبة

الإصدار ≥ C++‎ 17

انظر المثال التالي:

namespace a {
    namespace b {
        template < class T >
            struct qualifies: std::false_type {};
    }
}

namespace other {
    struct bob {};
}

namespace a::b {
    template < >
        struct qualifies < ::other::bob >: std::true_type {};
}

ابتداءً من C++‎ 17، صار بإمكانك الدخول إلى فضاء الاسم ‎a‎ و كذلك ‎b‎ بخطوة واحدة عبر التعبير ‎namespace a::b‎.

كنية فضاء الاسم

يمكن إعطاء فضاء الاسم كُنيةً أو اسمًا بديلًا (alias)، أي اسمًا آخر يمثّل فضاء الاسم نفسه باستخدام الصيغة ‎namespace identifier =‎، ويمكن الوصول إلى أعضاء فضاء الاسم المُكَنَّى عبر تأهيلهم (أي إسباقهم) بالكُنية.

في المثال التالي، فضاء الاسم الُمتشعّب ‎AReallyLongName::AnotherReallyLongName‎ طويل جدًّا، لذا تصرح الدالّة ‎qux‎ عن الكُنية ‎N‎. يمكن الآن الوصول إلى أعضاء فضاء الاسم باستخدام ‎N::‎. انظر:

namespace AReallyLongName {
    namespace AnotherReallyLongName {
        int foo();
        int bar();
        void baz(int x, int y);
    }
}
void qux() {
    namespace N = AReallyLongName::AnotherReallyLongName;
    N::baz(N::foo(), N::bar());
}

فضاء الاسم المضمن (Inline namespace)

الإصدار ≥ C++‎ 11

تُدرِج ‎inline ‎namespace‎ محتوى فضاء الاسم المُضمّن في فضاء الاسم المحيط (Enclosing)، لذلك فإنّ الشيفرة التالية:

namespace Outer {
    inline namespace Inner {
        void foo();
    }
}

تكافئ بشكل كبير الشيفرة أدناه:

namespace Outer {
    namespace Inner {
        void foo();
    }
    using Inner::foo;
}

غير أن عناصر ‎Outer::Inner::‎ وعناصر ‎Outer::‎ متطابقة، لذلك فإن السَّطرن التالين متكافئان:

Outer::foo();
Outer::Inner::foo();

لكنّ التعبير ‎using namespace Inner;‎ لن يكون مكافئًا لبعض الأجزاء مثل تخصيص القوالب (template specialization):

#include <outer.h> // انظر أسفله

class MyCustomType;
namespace Outer {
    template < >
        void foo < MyCustomType > () {
            std::cout << "Specialization";
        }
}

يسمح فضاء الاسم المُضمَّن بتخصيص ‎Outer::foo‎، انظر المثال التالي حيث أهملنا include guard من أجل التبسيط:

// outer.h
namespace Outer {
    inline namespace Inner {
        template < typename T >
            void foo() {
                std::cout << "Generic";
            }
    }
}

بينما لا يسمح التعبير ‎using namespace‎ بتخصيص ‎Outer::foo‎، انظر أدناه أيضًا حيث أهملنا include guard من أجل التبسيط:

// outer.h
namespace Outer {
    namespace Inner {
        template < typename T >
            void foo() {
                std::cout << "Generic";
            }
    }
    using namespace Inner;
    // `Outer::foo` لا يمكن تخصيص
    // `Outer::Inner::foo` الصيغة الصحيحة هي
}

تتيح فضاءات الاسم المُضمّنة لعدة إصدارات أن تتواجد في نفس الوقت بحيث تعود كلها افتراضيًّا إلى فضاء الاسم المُضمّن (‎inline‎):

namespace MyNamespace {
    // تضمين الإصدار الأخير
    inline namespace Version2 {
        void foo(); // إصدار جديد
        void bar();
    }
    namespace Version1 // الإصدار القديم
    {
        void foo();
    }
}

ومع استخدام:

MyNamespace::Version1::foo(); // الإصدار القديم
MyNamespace::Version2::foo(); // الاصدار الجديد
MyNamespace::foo(); // MyNamespace::Version1::foo(); الاصدار الافتراضي

تكنية فضاء اسم طويل

من الممكن تكنِية فضاءات الاسم الطويلة في ++C، وهو مفيد مثلًا في حال أردت الإشارة إلى مكوّنات مكتبة ما. انظر:

namespace boost {
    namespace multiprecision {
        class Number...
    }
}
namespace Name1 = boost::multiprecision;

// كلا التصريحين متكافئين
boost::multiprecision::Number X    // كتابة فضاء الاسم بأكمله
Name1::Number Y            // استخدام الكنية

نطاق تصريح الكنية

يتأثّر تصريح الكنية باستخدام تعليمات using الموجودة قبله:

namespace boost {
    namespace multiprecision {
        class Number...
    }
}

using namespace boost;

// فضاءا الاسم متكافئان
namespace Name1 = boost::multiprecision;
namespace Name2 = multiprecision;

لكن قد تكون عمليّة تكنية فضاء الاسم مربكة أحيانًا حول اختيار الفضاء الذي تريد وضع اسم بديل أو كنية له، كما في المثال التالي:

namespace boost {
    namespace multiprecision {
        class Number...
    }
}

namespace numeric {
    namespace multiprecision {
        class Number...
    }
}

using namespace numeric;
using namespace boost;

لا يُنصح بهذا لأنه ليس واضحًا إن كان Name1 يشير إلى numeric::multiprecision أم boost::multiprecision، نتابع:

namespace Name1 = multiprecision;
// يُفضل استخدام المسار الكامل
namespace Name2 = numeric::multiprecision;
namespace Name3 = boost::multiprecision;

هذا الدرس جزء من سلسلة دروس عن C++‎.

ترجمة -بتصرّف- للفصل Chapter 44: Namespaces والفصل Chapter 46: Using declaration من كتاب C++ Notes for Professionals

تُسمى الدوال المُعرّفة بالكلمة المفتاحية ‎inline‎ دوالًا مُضمّنة (inline functions)، ويمكن تعريفها أكثر من مرة دون انتهاك قاعدة التعريف الواحد (One Definition Rule)، وعليه يمكن تعريفها في الترويسة مع الارتباطات الخارجية.

التصريح عن دالّة ما بأنها مضمّنة يُخبر المصرّف أنّ تلك الدالّة يجب أن تُضمَّن أثناء توليد الشِّيفرة البرمجية (لكنّ ذلك غير مضمون).

الدوال المضمنة

تعريف الدوال غير التابعة المضمنة (Non-member inline function definition)

inline int add(int x, int y) {
    return x + y;
}

الدوال التابعة المضمنة (Member inline functions)

انظر المثال التالي:

// header (.hpp)
struct A {
    void i_am_inlined() {}
};
struct B {
    void i_am_NOT_inlined();
};
// source (.cpp)
void B::i_am_NOT_inlined() {}

ما المقصود بتضمين دالّة؟

نظر المثال التالي:

inline int add(int x, int y) {
    return x + y;
}
int main() {
    int a = 1, b = 2;
    int c = add(a, b);
}

في الشيفرة أعلاه، عندما تكون ‎add‎ مضمّنة، فستصبح الشيفرة الناتجة كما يلي:

int main() {
    int a = 1, b = 2;
    int c = a + b;
}

لا يمكن رؤية الدالة المضمّنة إذ يُضمَّن متنها في متن المُستدعي، ولو لم يكن التابع ‎add‎ مضمّنًا، لاستدعيَت الدالّة. الحِمل الإضافي (overhead) الناتج عن استدعاء دالة -مثل إنشاء إطار مكدِّس (stack frame) جديدة، ونسخ الوسائط، وإنشاء المتغيرات المحلية، وغير ذلك - سيكون مكلفًا.

التصريح عن الدوال المضمنة غير التابعة

يمكن التصريح عن الدوالّ المضّمنة غير التابعة على النحو التالي:

inline int add(int x, int y);

الدوال التابعة الخاصة

المنشئ الافتراضي (Default Constructor)

المُنشئ الافتراضي هو نوع من المُنشئات التي لا تتطلّب أيّ معاملات عند استدعائها وتُسمى باسم النوع الذي تنشئه، كما أنها تُعدّ دالة تابعة من توابعه، كما هو حال جميع المُنشئات.

class C {
    int i;
    public:
        // تعريف المنشئ الافتراضي
        C(): i(0) {         // إلى 0  i قائمة تهيئة العضو، هيئ
                // إنشاء جسم الدالّة -- يمكن فعل أشياء أكثر تعقيدا هنا
        }
};

C c1; 
C c2 = C(); 
C c3();
C c4 {}; 
C c5[2];
C * c6 = new C[2]; 

تحليل الشيفرة السابقة:

• C c1: يستدعي منشئ C الافتراضي لإنشاء الكائن c1.
• C c2: يستدعي المنشئ الافتراضي صراحة.
• C c3: خطأ: هذا الإصدار غير ممكن بسبب غموض في التحليل، أو ما يعرف بمشكلة “The most vexing parse”.
• C c4: يمكن استخدام { } في C++ 11 بطريقة مماثلة.
• C c5[2]‎: يستدعي المنشئ الافتراضي على عنصري المصفوفة.
• C * c6: يستدعي المنشئ الافتراضي على عنصري المصفوفة.

هناك طريقة أخرى للاستغناء عن تمرير المعاملات، وهي أن يوفّر المطوِّر قيمًا افتراضية لها جميعًا:

class D {
    int i;
    int j;
    public:
        // من الممكن أيضا استدعاء منشئ افتراضي بدون معاملات
        D(int i = 0, int j = 42): i(i), j(j) {}
};
D d; // مع القيم الافتراضية للوسائط D استدعاء منشئ 

يوفر المصرِّف منشئًا افتراضيًا فارغًا بشكل ضمني في بعض الحالات، كأن يكون المطور لم يوفر منشئًا ولم تكن ثمة شروط مانعة أخرى.

class C {
    std::string s; // تحتاج الأعضاء إلى أن تكون قابلة للإنشاء
};
C c1; // لها منشئ افتراضي معرّف ضمنيا C 

وجود نوع آخر من المنشئ هو أحد الشروط المانعة المذكورة سابقًا:

class C {
    int i;
    public:
        C(int i): i(i) {}
};
C c1; // ليس لها منشئ افتراضي ضمني C ،خطأ في التصريف

الإصدار <C++‎ 11

إحدى الطرق الشائعة لمنع إنشاء مُنشئ افتراضي ضمني هي جعله خاصًّا ‎private‎ (بلا تعريف)، والهدف من ذلك هو إطلاق خطأ تصريفي في حال حاول شخص ما استخدام المنشئ، وينتج عن هذا إمّا خطأ في الوصول (Access to private error) أو خطأ ربط (linker error)، حسب نوع المصرّف.

وللتأكد من أنّ مُنشئًا افتراضيًّا (مشابه وظيفيًا للمنشئ الضمني) قد تمّ تعريفه، يكتب المُطوِّر منشئًا فارغًا بشكل صريح.

الإصدار C++‎ 11

في الإصدار C++‎ 11، يستطيع المطوّر أيضًا استخدام الكلمة المفتاحية ‎delete‎ لمنع المصرّف من توفير مُنشئ افتراضي.

class C {
    int i;
    public:
        // يُحذف المنشئ الافتراضي بشكل صريح
        C() = delete;
};
C c1; // C خطأ تصريفي: حذف منشئ

أيضًا، إن أردت أن يوفرّ المصرّف مُنشئًا افتراضيًّا، فذلك يكون على النحو التالي:

class C {
    int i;
    public:
        // توفير منشئ افتراضي تلقائيا
        C() =
        default;
    C(int i): i(i) {}
};
C c1; // مُنشأة افتراضيا
C c2(1); // int مُنشأة عبر المنشئ

الإصدار C++‎ 14

يمكنك تحديد ما إذا كان لنوعٍ ما مُنشئ افتراضي (أو أنه نوع أولي - primitive type) باستخدام

‎std::is_default_constructible from <type_traits>‎

إليك الشيفرة:

class C1 {};
class C2 {
    public: C2() {}
};
class C3 {
    public: C3(int) {}
};

using std::cout;
using std::boolalpha;
using std::endl;
using std::is_default_constructible;
cout << boolalpha << is_default_constructible < int > () << endl; // true
cout << boolalpha << is_default_constructible < C1 > () << endl; // true
cout << boolalpha << is_default_constructible < C2 > () << endl; // true
cout << boolalpha << is_default_constructible < C3 > () << endl; // false

الإصدار = C++‎ 11

في الإصدار C++‎ 11، من الممكن استخدام الإصدار غير الدّالي (non-functor) لـ ‎std::is_default_constructible‎:

cout << boolalpha << is_default_constructible<C1>::value << endl; // true

المُدمِّر (Destructor)

المُدمّر هو دالّة بدون وسائط تُستدعى قُبيْل تدمير كائن مُعرّف من المستخدم (user-defined object)، ويُسمّى باسم النوع الذي يدمِّره مسبوقًا بـ ‎~‎ .

class C {
    int* is;
    string s;
    public:
        C(): is(new int[10]) {}~C() { // تعريف المُدمّر
            delete[] is;
        }
};
class C_child: public C {
    string s_ch;
    public:
        C_child() {}~C_child() {} // مدمّر الصنف الفرعي
};
void f() {
    C c1; 
    C c2[2];
    C* c3 = new C[2];
    C_child c_ch; 
    delete[] c3; 
} // يتم تدمير المتغيرات التلقائية هنا

تحليل الشيفرة السابقة:

• C c1: استدعاء المدمر الافتراضي.
• [C c2[2: استدعاء المُدمّر الافتراضي على العنصرين.
• [C* c3 = new C[2: استدعاء المُدمّر الافتراضي على عنصرَي المصفوفة
• C_child c_ch: عند تدميره يستدعي مدمر s_ch من قاعدة C (ومن ثم، s)
• delete[] c3: يستدعي المدمرات على [c3[0 و [c3[1.

يوفر المصرِّف مدمرًا افتراضيًا بشكل ضمني في بعض الحالات، كأن يكون المطور لم يوفر مدمرًا ولم تكن ثمة شروط مانعة أخرى.

class C {
    int i;
    string s;
};
void f() {
    C* c1 = new C;
    delete c1; // له مُدمّر C 
}

class C {
    int m;
    private:
        ~C() {} // لا يوجد مُدمّر عام
};
class C_container {
    C c;
};
void f() {
    C_container* c_cont = new C_container;
    delete c_cont; // Compile ERROR: C has no accessible destructor
}

الإصدار > C++‎ 11

في C++‎ 11، يستطيع المُطوِّر تغيير هذا السلوك عن طريق منع المُصرّف من توفير مدمِّر افتراضي.

class C {
    int m;
    public:
        ~C() = delete; // لا يوجد مُدمّر ضمني
};
void f {
    C c1;
} // Compile ERROR: C has no destructor

يمكنك أن تجعل المصرّف يوفّر مدمّرًا افتراضيًّا، انظر:

class C {
    int m;
    public:
        ~C() =
        default;
};
void f() {
    C c1;
} // بنجاح c1 لها مُدمّر وقد تم تدمير  C

الإصدار> C++‎ 11

يمكنك تحديد ما إذا كان لنوعٍ ما مدمّرٌ ما (أو أنّه نوع أولي) باستخدام ‎std::is_destructible‎ من <type_traits>:

class C1 {};
class C2 {
    public: ~C2() = delete
};
class C3: public C2 {};
using std::cout;
using std::boolalpha;
using std::endl;
using std::is_destructible;
cout << boolalpha << is_destructible < int > () << endl; // true
cout << boolalpha << is_destructible < C1 > () << endl; // true
cout << boolalpha << is_destructible < C2 > () << endl; // false
cout << boolalpha << is_destructible < C3 > () << endl; // false

النسخ والمبادلة (Copy and swap)

إذا أردت كتابة صنف لإدارة الموارد فستحتاج إلى تنفيذ جميع الدوال التابعة الخاصّة (انظر قاعدة الثلاثة/خمسة/صفر). والطريقة الأبسط لكتابة مُنشئ النسخ (copy constructor) وعامل الإسناد (assignment operator) هي:

person(const person &other): name(new char[std::strlen(other.name) + 1]), age(other.age) {
    std::strcpy(name, other.name);
}

person& operator = (person
    const& rhs) {
    if (this != &other) {
        delete[] name;
        name = new char[std::strlen(other.name) + 1];
        std::strcpy(name, other.name);
        age = other.age;
    }

    return *this;
}

لكنّ هذه المقاربة تعتريها بعض العيوب، فهي تفشل في ضمان الاعتراض القوي (strong exception guarantee) إذا أطلق ‎new[]‎ فسنكون قد محونا الموارد التي يملكها ‎this‎ سلفًا، ولن نستطيع استردادها.

وهناك الكثير من التكرار في شيفرتي إنشاء النسخ (copy construction) وإسناد النسخ (copy assignment)، ولا ننسى كذلك التحقّق من الإسناد الذاتي (self-assignment) الذي يضيف حِملًا زائدًا إلى عملية النسخ عادة، لكنّه يبقى ضروريًّا.

يمكننا استخدام أسلوب النسخ والمبادلة (copy-and-swap idiom) لتلبية ضمان الاستثناء القوي (strong exception guarantee) وتجنّب تكرار الشيفرة:

class person {
    char* name;
    int age;
    public:
        /* كل الدوالّ الأخرى */
        friend void swap(person & lhs, person & rhs) {
            using std::swap; // enable ADL
            swap(lhs.name, rhs.name);
            swap(lhs.age, rhs.age);
        }
    person & operator = (person rhs) {
        swap( *this, rhs);
        return *this;
    }
};

إن عجبت من سبب نجاح الشيفرة السابقة، فانظر ما سيحدث حين يكون لدينا ما يلي:

person p1 = ...;
person p2 = ...;
p1 = p2;

أولاً، ننسخ ‎rhs‎ من ‎p2‎ (والذي لم يكن علينا تكراره هنا). لن يكون علينا فعل أيّ شيء في ‎operator=‎ في حال رفع اعتراض (throwing an exception) وسيبقى ‎p1‎ دون تغيير. بعد ذلك، سنُبادل الأعضاء بين ‎*this‎ و ‎rhs‎، ثم سيخرُج ‎rhs‎ عن النطاق. ستُنظّف المواردَ الأصلية الخاصّة بالمؤشّر this ضمنيًا داخل العامل ‎operator=‎من خلال المدمّر، والذي لم يكن علينا أن نكرره.

حتى الإسناد الذاتي (self-assignment) سيعمل بلا مشاكل - لكنّه سيكون أقل كفاءة باستخدام النسخ والمبادلة (إذ يتطلّب تخصيصًا - allocation - وإلغاء تخصيص - deallocation - إضافي)، ولكن إذا كان هذا الأمر مستبعدًا، فلن يؤثّر على الأداء العامّ.

الإصدار ≥ C++‎ 11

تعمل الصيغة أعلاه كما هي بالنسبة لإسناد النقل (move assignment).

p1 = std::move(p2);

هنا، ننقل/ننشئ ‎rhs‎ من ‎p2‎، وتبقى الشيفرة الأخرى صالحة، فإذا كان صنفٌ ما قابلًا للنقل لكن غير قابل للنسخ، فلا داعي لحذف إسناد النسخ، لأنّ عامل الإسناد سيكون معطوبَ الصياغة بسبب مُنشئ النسخ المحذوف.

النقل والنسخ الضمني

اعلم أنّ التصريح عن مدمِّر يمنع المصرّف من إنشاء مُنشئات النقل (move constructors) وعوامل إسناد النقل (move assignment operators) ضمنيًّا، وتذكر في حال صرّحت بمدمّر أن تضيف التعريفات المناسبة لعمليات النقل.

وسيؤدّي التصريح عن عمليات النقل إلى منع إنشاء عمليات النسخ، لذا يجب إضافتها هي أيضًا (إذا كانت كائنات هذا الصنف تحتاج إلى عمليات النسخ).

class Movable {
    public:
        virtual~Movable() noexcept = default;
    // المنشئ لن ينشئ هذا التعبير الخاطئ لأننا عرّفنا مُدمّرا
    Movable(Movable && ) noexcept = default;
    Movable & operator = (Movable && ) noexcept = default;
    // التصريح عن عمليات النقل سيمنع إنشاء عمليات النسخ إلا إن قمنا بتمكين ذلك صراحة
    Movable(const Movable& ) = default;
    Movable & operator = (const Movable& ) = default;
};

الدوال التابعة غير الساكنة (Non-static member functions)

من الممكن أن يكون للأصناف (‎class‎) والبنيات (‎struct‎) دوال تابعة أو متغيرات عضوية، وصياغة الدوالّ التابعة تشبه صياغة الدوالّ المستقلة، ويمكن تعريفها إمّا داخل الصنف أو خارجه، فإذا عُرِّفت خارج تعريف الصنف فإنّ اسم الدالّة سيُسبَق باسمِ الصنف ومعامل النطاق (‎::‎).

class CL {
    public: void definedInside() {}
    void definedOutside();
};
void CL::definedOutside() {}

تُستدعى هذه الدوالّ على نسخة (أو مرجع إلى نسخة) من الصنف باستخدام العامل النُّقَطي (dot operator -‏‏ (‎.‎))، أو مؤشّر إلى نسخة باستخدام عامل السهم (arrow operator -‏‏ (‎->‎))، ويرتبط كل استدعاء بالنسخة التي استُدعِيت عليها الدالّة.

وعندما يُستدعى تابع على نسخة فسيكون له حقّ الوصول إلى كافّة حقول تلك النسخة (عبر المؤشّر ‎this‎)، ولكن لا يمكنه الوصول إلى حقول النسخ الأخرى إلا إذا مُرِّرت كمعاملات.

struct ST {
    ST(const std::string & ss = "Wolf", int ii = 359): s(ss), i(ii) {}
    int get_i() const {
        return i;
    }
    bool compare_i(const ST & other) const {
        return (i == other.i);
    }
    private:
        std::string s;
    int i;
};
ST st1;
ST st2("Species", 8472);
int i = st1.get_i();            // st2.i ولكن ليس إلى st1.i يمكن الوصول إلى 
bool b = st1.compare_i(st2);    // st1 و  st2 يمكن الوصول إلى

يُسمح لهذه الدوالّ بالوصول إلى الحقول و/أو التوابع الأخرى بغضّ النظر عن مُحدِّدات الوصول (access modifiers) الخاصّة بالمتغيرات والتوابع. كذلك يمكن كتابتها والوصول إلى الحقول و/أو استدعاء التوابع المُصرّحة قبلها، إذ يجب تحليل تعريف الصنف بأكمله قبل أن يبدأ المصرّف في تصريفه.

class Access {
    public:
        Access(int i_ = 8088, int j_ = 8086, int k_ = 6502): i(i_), j(j_), k(k_) {}
    int i;
    int get_k() const {
        return k;
    }
    bool private_no_more() const {
        return i_be_private();
    }
    protected:
        int j;
    int get_i() const {
        return i;
    }
    private:
        int k;
    int get_j() const {
        return j;
    }
    bool i_be_private() const {
        return ((i > j) && (k < j));
    }
};

التغليف (Encapsulation)

هُنالك عدّة استعمالات للتوابع، من ذلك أنها تُستخدم للتغليف (encapsulation)، وذلك باستخدام جالِب (getter) ومُعيِّن (setter) بدلاً من السماح بالوصول إلى الحقول مباشرة.

class Encapsulator {
    int encapsulated;
    public:
        int get_encapsulated() const {
            return encapsulated;
        }
    void set_encapsulated(int e) {
        encapsulated = e;
    }
    void some_func() {
        do_something_with(encapsulated);
    }
};

يمكن الوصول إلى الحقل ‎encapsulated‎ داخل الصنف من قِبل أيّ دالة تابعة غير ساكنة، أمّا خارج الصنف، فيُنظّم حق الوصول إليه بواسطة الدوال التابعة إذ يُستخدم ‎get_encapsulated()‎ لقراءته و ‎set_encapsulated()‎ لتعديله، هذا يمنع التعديلات غير المقصودة على المتغيّر (هناك العديد من النقاشات حول ما إذا كانت الجوالب والمعيّنات تدعم التغليف أم تكسره، ولكلٍّ من الطرفين وجهة نظرة وجيهة).

إخفاء الأسماء واستيرادها

عندما يوفّر صنف أساسي مجموعة من الدوالّ زائدة التحميل (overloaded functions)، ثم يضيف صنفٌ مشتق تحميلًا زائدًا آخر إلى المجموعة، فإنّ ذلك سيخفي كل التحميلات الزائدة الخاصّة بالصنف الأساسي.

struct HiddenBase {
    void f(int) {
        std::cout << "int" << std::endl;
    }
    void f(bool) {
        std::cout << "bool" << std::endl;
    }
    void f(std::string) {
        std::cout << "std::string" << std::endl;
    }
};
struct HidingDerived: HiddenBase {
    void f(float) {
        std::cout << "float" << std::endl;
    }
};
// ...
HiddenBase hb;
HidingDerived hd;
std::string s;
hb.f(1); // الخرج:  int
hb.f(true); // الخرج: bool
hb.f(s); // الخرج: std::string;
hd.f(1. f); // الخرج: float
hd.f(3); // الخرج: float
hd.f(true); // الخرج: float
hd.f(s); // Error: Can't convert from std::string to float.

هذا السلوك ناتج عن قواعد تحليل الاسم (name resolution rules): فأثناء البحث عن الاسم، يتوقف البحث بمجّرد العثور على الاسم الصحيح حتى لو لم يُعثَر على الإصدار الصحيح للكيان الذي يحمل ذلك الاسم (مثل ‎hd.f(s)‎)، ونتيجة لهذا، تؤدي زيادة تحميل دالّة في الصنف المشتق إلى منع الوصول إلى التحميل الزائد الموجود في الصنف الأساسي. ولكي لتجنّب ذلك، يمكن استخدام using لأجل "استيراد" الأسماء من الصنف الأساسي إلى الصنف المشتق حتى تكون متاحة أثناء البحث عن الاسم. انظر المثال التالي حيث يجب أن تُعد جميع الأعضاء المسمّاة HiddenBase::f أعضاءً من HidingDerived أثناء البحث:

struct HidingDerived: HiddenBase {
    using HiddenBase::f;
    void f(float) {
        std::cout << "float" << std::endl;
    }
};
// ...
HidingDerived hd;
hd.f(1. f); //  الخرج: float
hd.f(3); // الخرج: int
hd.f(true); // الخرج:  bool
hd.f(s); // الخرج: std::string

إذ كان الصنف المشتق يستورد الأسماء باستخدام using ولكن يُصرّح كذلك عن دوالّ لها نفس بصمات الدوالّ في الصنف الأساسي، فسيُعاد تعريف دوالّ الصنف الأساسي بصمت أو تُخفى.

struct NamesHidden {
    virtual void hide_me() {}
    virtual void hide_me(float) {}
    void hide_me(int) {}
    void hide_me(bool) {}
};
struct NameHider: NamesHidden {
    using NamesHidden::hide_me;
    void hide_me() {} // NamesHidden::hide_me() إعادة تعريف
    void hide_me(int) {} // NamesHidden::hide_me(int) إخفاء
};

يمكن أيضًا استخدام تصريح using لتغيير معدِّلات الوصول (Access Modifiers)، بشرط أن يكون الكيان المستورد إمّا عامًّا (‎public‎) أو محميًا (‎protected‎) في الصنف الأساسي.

struct ProMem {
    protected: void func() {}
};
struct BecomesPub: ProMem {
    using ProMem::func;
};
// ...
ProMem pm;
BecomesPub bp;
pm.func(); // خطأ: محميّ
bp.func(); // جيد

وبالمثل إذا أردنا استدعاء دالة تابعة من صنف محدد في التسلسل الهرمي الوراثي (inheritance hierarchy) بشكل صريح، فيمكننا تأهيل اسم الدالّة عند استدعائها، وتحديد ذلك الصنف بالاسم.

struct One {
    virtual void f() {
        std::cout << "One." << std::endl;
    }
};

struct Two: One {
    void f() override {
        One::f(); // this->One::f();
        std::cout << "Two." << std::endl;
    }
};
struct Three: Two {
    void f() override {
        Two::f(); // this->Two::f();
        std::cout << "Three." << std::endl;
    }
};

// ...

Three t;

t.f(); 
t.Two::f();
t.One::f();
}

تحليل الشيفرة السابقة:

• ()t.f: الصيغة العادية.
• ()t.Two::f: استدعاء إصدار ()f المعرَّف في Two.
• ()t.One::f: استدعاء إصدار ()f المعرَّف في One.

الدوال التابعة الوهميّة

الدوال التوابع يمكن أن تكون وهمية (‎virtual‎)، وإن استُدعِيت على مؤشّر أو مرجع إلى نسخة فلن يتم الوصول إليها مباشرة، بل سيُبحَث عن الدالّة في جدول الدوالّ الوهمية (قائمة من المؤشّرات-إلى-الدوال التابعة التي تشير إلى الدوالّ الوهمية، والمعروفة باسم ‎vtable‎ أو ‎vftable‎)، ثم تُستخدَم لاستدعاء الإصدار المناسب للنوع (الفعلي) الديناميكي للنسخة. ولن يتم أي بحث إذا استُدعيت الدالّة مباشرة من متغير داخل صنف ما.

struct Base {
    virtual void func() {
        std::cout << "In Base." << std::endl;
    }
};
struct Derived: Base {
    void func() override {
        std::cout << "In Derived." << std::endl;
    }
};
void slicer(Base x) {
    x.func();
}
// ...
Base b;
Derived d;
Base * pb = & b, * pd = & d; // مؤشّرات
Base & rb = b, & rd = d; // مراجع

int main() {

b.func(); // الخرج: In Base.
d.func(); // الخرج: In Derived.

pb -> func(); // الخرج: In Base.
pd -> func(); // الخرج: In Derived.

rb.func(); // الخرج: In Base.
rd.func(); // الخرج: In Derived.

slicer(b); // الخرج: In Base.
slicer(d); // الخرج: In Base.
}

ورغم أن ‎pd‎ من النوع ‎Base*‎ و‎rd‎ من النّوع ‎Base&‎، إلا أن استدعاء ‎func()‎ على أيّ منهما سيؤدّي إلى استدعاء ‎Derived::func()‎ بدلاً من Base::func()‎؛ وذلك لأنّ جدول ‎vtable‎ الخاصّ بالبنية ‎Derived‎ يُحدِّث المدخل ‎Base::func()‎ بدلاً من الإشارة إلى ‎Derived::func()‎.

ومن ناحية أخرى، لاحظ كيف يؤدّي تمرير نسخة إلى ‎slicer()‎ إلى استدعاء ‎Base::func()‎ حتى عندما تكون النسخة المُمرَّرة من نوع ‎Derived‎، وهذا بسبب مفهوم يُعرف بتشريح البيانات (Data Slicing)، وفيه يؤدّي تمرير نسخة من ‎Derived‎ إلى مُعامل من النوع ‎Base‎ بالقيمة (by value) إلى عرض ذلك الجزء من ‎Derived‎ الذي يمكنه الوصول إلى نسخة Base.

حين تُعرَّف دالة تابعة على أنّها وهمية فإنّ جميع دوال الصنف التابعة المشتقة التي تحمل نفس البصمة ستعيد تعريفه (override) بغضّ النظر عمّا إذا كانت الدالّة التي أعادت تعريفه وهمية أم لا، هذا سيُصعِّب عملية تحليل الأصناف المشتقّة على المبرمجين لعدم وجود أيّ إشارة تحدّد أيٌّ من تلك دوالّ وهمية.

struct B {
    virtual void f() {}
};
struct D: B {
    void f() {} // B::f وهمية بشكل ضمني، إعادة تعريف
    // B لكن عليك التحقق من
};

لاحظ أنّ الدالّة مشتقة (Derived Function) لا يمكنها أن تعيد تعريف دالّة أساسية (Base Function) إلا إذا تطابقت بصماتهما، حتى لو صُرِّح بأنّ الدالّة المشتقة وهمية (‎virtual‎)، فستنشئ دالّةً وهمية جديدة إن لم لتطابق البصمات.

struct BadB {
    virtual void f() {}
};
struct BadD: BadB {
    virtual void f(int i) {} // BadB::f لا تُعِد تعريف
};

الإصدار ≥ C++‎ 11

اعتبارًا من الإصدار C++‎ 11، يمكن التصريح بنِيَّة إعادة التعريف (override) باستخدام الكلمة المفتاحية ‎override‎، واعلم أن هذه الكلمة حساسة للسياق، وسيخبر ذلك المصرّف أنّ المبرمج يتوقع منه أن يعيد تعريف دالّة الصنف الأساسي، وعليه يطلق المصرِّف خطأً إذا لم تحدث عملية إعادة التعريف.

struct CPP11B {
    virtual void f() {}
};
struct CPP11D: CPP11B {
    void f() override {}
    void f(int i) override {} // Error: Doesn't actually override anything.
};

وفائدة هذا أنه يخبر المبرمجين بأنّ الدالّة وهمية، وأنها كذلك مُصرَّحة في صنف أساسي واحد على الأقل، مما يسهّل تحليل الأصناف المعقّدة.

يجب تضمين المُحدِّد ‎virtual‎ في تصريح الدالّة وعدم تكراره في التعريف عند التصريح بأنّ دالّة ما وهمية ‎virtual‎ وتكون معرَّفة خارج تعريف الصنف.

الإصدار ≥ C++‎ 11

ينطبق هذا أيضًا على الكلمة المفتاحية ‎override‎.

struct VB {
    virtual void f(); // هنا "virtual" ضع
    void g();
};
/* virtual */
void VB::f() {} // لكن ليس هنا
virtual void VB::g() {} // خطأ 

وإن نفذ الصنف الأساسي زيادة تحميل على دالّة وهمية، فإن التحميلات التي حُدِّدَت على أنها وهمية بشكل صريح هي وحدها التي ستكون وهمية.

struct BOverload {
    virtual void func() {}
    void func(int) {}
};
struct DOverload: BOverload {
    void func() override {}
    void func(int) {}
};
// ...
BOverload* bo = new DOverload;
bo - > func(); // DOverload::func() استدعاء
bo - > func(1); // BOverload::func(int) استدعاء

الثباتية (Const Correctness)

أحد الاستخدامات الرئيسية لمؤهلات المؤشّر ‎this‎ هو الصحة الثباتية، أو الثباتية باختصار (const correctness). تضمن هذه الممارسة عدم تعديل الكائن إلا عند الحاجة لهذا، وأنّ أيّ دالّة (عضوة أو غير عضوة) لا تحتاج إلى تعديل كائن ما لن تملك حق الكتابة في ذلك الكائن (سواء بشكل مباشر أو غير مباشر). هذا يمنع التعديلات غير المقصودة مما يجعل الشيفرة أكثر متانة، كما يسمح لأيّ دالّة لا تحتاج إلى تعديل الحالة لأن تقبل الكائنات سواء كانت ثابتة (‎const‎) أو غير ثابتة دون الحاجة إلى إعادة كتابة أو تحميل الدالّة.

تبدأ الثباتية من أسفل إلى أعلى، وذلك بسبب طبيعتها، إذ تُصرَّح أيّ دالة تابعة في الصنف لا تحتاج إلى تغيير الحالة على أنها ثابتة (‎const‎)، وذلك كي يمكنَ استدعاؤها على النسخ الثابتة. هذا يسمح بدوره بالتصريح أنّ المُعاملات المُمرّرة بالمرجع (passed-by-reference) ثابتة عندما لا تكون هناك حاجة إلى تعديلها، ممّا يسمح للدوالّ بأخذ كائنات ثابتة أو غير ثابتة دون مشاكل، كما يمكن للثباتيّة أن تنتشر للخارج بهذه الطريقة. وتكون الجالبات (Getters) ثابتة كأي دالّة أخرى لا تحتاج إلى تعديل حالة الكائن المنطقية.

class ConstIncorrect {
    Field fld;
    public:
        ConstIncorrect(const Field & f): fld(f) {} // تعديل
    const Field & get_field() {
        return fld;
    } // لا يوجد تعديل، ينبغي أن تكون ثابتة
    void set_field(const Field & f) {
        fld = f;
    } // تعديل
    void do_something(int i) { // تعديل
        fld.insert_value(i);
    }
    void do_nothing() {} // لا يوجد تعديل، ينبغي أن تكون ثابتة
};
class ConstCorrect {
    Field fld;
    public:
        ConstCorrect(const Field & f): fld(f) {} // غير ثابتة: يمكن التعديل
    const Field & get_field() const {
        return fld;
    } // ثابتة: لا يمكن التعديل
    void set_field(const Field & f) {
        fld = f;
    } // غير ثابتة: يمكن التعديل
    void do_something(int i) { // غير ثابتة: يمكن التعديل
        fld.insert_value(i);
    }
    void do_nothing() const {} // ثابتة: لا يمكن التعديل
};
// ...
const ConstIncorrect i_cant_do_anything(make_me_a_field());
Field f = i_cant_do_anything.get_field();
// ليست ثابتة get_field() ،خطأ
i_cant_do_anything.do_nothing();
// خطأ كالأعلى
const ConstCorrect but_i_can(make_me_a_field());
Field f = but_i_can.get_field(); //جيد 
but_i_can.do_nothing(); // جيد

كما هو موضّح في تعليقات ‎ConstIncorrect‎ و ‎ConstCorrect‎، فإنّ تأهيل الدوالّ يمكن أن يُستخدم في التوثيق. يمكن افتراض أن أي دالة غير ثابتة ستغير الحالة إذا كان صنفُ ما صحيحًا وفق مفهوم الثبات،وكذلك أيّ دالّة ثابتة لن تغيّر الحالة.

الدوال التابعة الثابتة للأصناف

يوضّح المثال التالي مفهوم الدوال التابعة الثابتة:

#include <iostream>
#include <map>
#include <string>

using namespace std;

class A {
public:
map<string, string> * mapOfStrings;
public:
A() {
mapOfStrings = new map<string, string>();
}

void insertEntry(string const & key, string const & value) const {
(*mapOfStrings)[key] = value;            // هذا يعمل بنجاح.
delete mapOfStrings;                // وهذا أيضًا.
mapOfStrings = new map<string, string>();     // أما هذا فلا يعمل.
}

void refresh() {
delete mapOfStrings;
mapOfStrings = new map<string, string>(); // ليست دالة ثابتة refresh يعمل لأن.
}

void getEntry(string const & key) const {
cout << mapOfStrings->at(key);
}
};

int main(int argc, char* argv[]) {

A var;
var.insertEntry("abc", "abcValue");
var.getEntry("abc");
getchar();
return 0;
}