المكررات (Iterators) وسيلة لتنفيذ عمليات على سلسلة عناصر على التوالي، رغم أنها ليست عناصر في نفسها، وإنما هي في الأساس عبارة عن مواضع (Positions)، كذلك فإنها امتداد لمفهوم المؤشرات، انظر المثال التالي:

A B C

يحتوي التسلسل السابق على ثلاثة عناصر، وأربعة مواضع كما يوضح التمثيل التالي:

+---+---+---+---+
| A  |  B | C |    |
+---+---+---+---+

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

من المكرِّرات إلى القيم

للانتقال من موضع إلى قيمة، يجب أن يُحصّل (dereferenced) المُكرِّر:

auto my_iterator = my_vector.begin(); // موضع
auto my_value = *my_iterator; // قيمة

يمكن النظر إلى المُكرِّر كمُحصِّلٍ للقيمة التي يشير إليها في التسلسل، لهذا يجب ألا تحاول أبدًا تحصيل الموضع end()‎ في التسلسل:

+---+---+---+---+
| A  |  B | C |    |
+---+---+---+---+
↑               ↑
|               +-- مكرّر لا يشير إلى أي قيمة، لا تحاول تحصيله
+---------------   A تحصيل هذا المكرّر سيعيد القيمة

سيعيد التعبير begin() مكرِّرًا يشير إلى الموضع الأول، وذلك في جميع التسلسلات والحاويات (Containers) الموجودة في مكتبة C++ القياسية، بينما سيعيد end() مكرِّرًا يشير إلى موضع يلي الموضع الأخير (وليس الموضع الأخير نفسه)، لهذا تسمى تلك المكررات أحيانًا first و last. انظر المثال التالي:

+---+---+---+---+
|  A | B | C |     |
+---+---+---+---+
↑               ↑
|                |
+- first       +- last

من الممكن الحصول على مُكرِّر لأي تسلسل، ذلك أن جميع التسلسلات -حتى الفارغة منها- تحتوي على موضع واحد على الأقل:

+---+
|      |
+---+

في التسلسل الفارغ، يمثّل كل من begin()‎ و end()‎ نفس الموضع، ولا يمكن تحصيل أيّ منهما، انظر المثال التالي:

+---+
|      |
+-----+
    ↑
    |
   +- empty_sequence.begin()
   | 
  +- empty_sequence.end()

كذلك يمكن تصوّر المكرِّرات على أنها إشارات تحدد المواضع بين العناصر:

+---+---+---+
| A | B | C |
+---+---+---+
↑    ^    ^    ↑
|                 |
+- first       +- last

ووفقًا لهذا التصوّر فإنّ تحصيل المُكرِّر سيعيد مرجعًا إلى العنصر الذي يأتي بعد المُكرِّر، وهذا مفيد في العمليات التالية:

• عمليات insert ستدرج عنصرًا في الموضع الذي يشير إليه المكرر.
• عمليات erase ستعيد مكررًا يتوافق مع نفس الموضع الذي تم المرور عليه.
• يتواجد المُكرّر، ومُكرّره المعكوس (Reverse Iterator) في نفس الموضع بين العناصر.

المكرِّرات غير الصالحة (Invalid Iterators)

يصير المكرر غيرَ صالحٍ إن لم يعد موضعُه جزءًا من التسلسل (مثال: أثناء عملية ما)، ولا يمكن تحصيل المكرر غير الصالح إلا بعد إسناده (Assign) إلى موضع آخر صالح. انظر المثال التالي الذي يكون فيه first صالحًا، ثم يخرج foo عن النطاق ويحذف، فيصير first بعد ذلك غير صالح.

std::vector<int>::iterator first;
{
    std::vector<int> foo;
    first = foo.begin();
}

الخوارزميات ودوال توابع التسلسلات (sequence member functions) التي في مكتبة C++‎ القياسية لديها قواعد تضبط التعامل مع المكررات حين يتم إبطالها (invalidated)، ولكل خوارزمية طريقة مختلفة في التعامل مع المكررات وإبطالها.

التنقل باستخدام المكررات

تُستخدم المكررات للتنقل بين عناصر التسلسل إذ ينقل المكرر موضعه خلال التسلسل، ويستطيع أن يتحرك في كلا الاتجاهين، للأمام أو للخلف.

auto first = my_vector.begin();

// تقديم المكرر بمَوضع واحد
++first;                        

// تقديم المكرَر بموضع واحد
std::advance(first, 1);         

// إعادة المكرَر إلى العنصر التالي
first = std::next(first);         

// تأخير المكرَر بموضع واحد
std::advance(first, -1);        

// إعادة المكرَر 20 موضعا إلى الأمام
first = std::next(first, 20);     

// إعادة المكرر 5 مواضع إلى الخلف
first = std::prev(first, 5);    

// إعادة المسافة بين مكرّرين
auto dist = std::distance(my_vector.begin(), first);

يجب أن يكون الوصول من الوسيط الأول إلى الوسيط الثاني لـ std::distance ممكنًا، بمعنى أن يكون first أصغر من أو يساوي second. ورغم أنك تستطيع إجراء عمليات حسابية على المكررات إلا أن هذا لا يعني أن جميع العمليات قابلة للتطبيق على المكررات كلها، فقد تصلح العملية a = b + 3;‎ لمكررات الوصول العشوائي (Random Access Iterators)، لكنها لن تصلح مع المكررات الأمامية (Forward Iterators) أو ثنائية الاتجاه (Bidirectional) التي يمكن نقلها ثلاثة مواضع للأمام عبر التعليمة b = a; ++b; ++b; ++b;‎، لذلك يوصى باستخدام دوال خاصة إن لم تكن تعرف نوع المكرِّر، كما في حالة قوالب الدوال التي تقبل المكررات.

مفاهيم المُكرِّرات (Iterator Concepts)

يصف معيار C++‎ العديد من مفاهيم المكررات، وقد جُمعت معًا وفقًا لسلوكها في التسلسلات التي تشير إليها، فإن عرفت السلوك العام للمكرِّر، عرفتَ سلوكه في أي تسلسل يشير إليه. وتوصف مفاهيم المكررات تلك مرتبة من أكثرهًا تقييدًا إلى أقلها:

• مكررات الدخل (Input Iterators): يمكن تحصيلها مرة واحدة فقط لكل موضع، ويمكن نقلها للأمام موضعًا واحدًا فقط في كل مرة، إذ لا تنتقل للوراء.
• مكررات التقدم (Forward Iterators): يمكن تحصيل هذه المكرّرات أيّ عدد من المرات.
• المكرّرات ثنائية الاتجاه (Bidirectional Iterators): هي مكررات تقدم تستطيع التحرك للخلف كذلك موضعًا واحدًا في كل مرة.
• المكرّرات العشوائية (Random Access Iterators): هي مكرّرات ثنائية الاتجاه تتحرك بحرية للأمام أو الخلف أي عدد من المواضع في كل مرة.
• المكرّرات المتجاورة (Contiguous Iterators) (منذ C++17): هي مكرّرات عشوائية تضمن أنّ البيانات التي تشير إليها متجاورة في الذاكرة. قد تختلف الخوارزميات وفقًا لمفاهيم المكرِّرات، فرغم إمكانية تقديم random_shuffle مثلًا للمكرِّرات الأماميّة إلا أن هناك بديلًا يتطلب مكرِّرات عشوائية يمكن توفيره، وسيكون أفضل.

سمات المُكرِّرات (Iterator traits)

توفّر سمات المكرّرات واجهة موحّدة لخصائص المكرِّرات. إذ تسمح لك بجلب نوع القيمة value_type ونوع الفرق difference_type وكذلك المؤشر pointer والمرجع reference، إضافة إلى فئة المكرر iterator_category، انظر المثال التالي:

template <class Iter>
Iter find(Iter first, Iter last, typename std::iterator_traits<Iter>::value_type val)
{
   while (first != last)
   {
       if (*first == val)
           return first;
       ++first;
   }
   return last;
}

يمكن استخدام فئة المُكرِّر iterator_category لتخصيص الخوارزميات:

template <class BidirIt>
void test(BidirIt a, std::bidirectional_iterator_tag)
{
    std::cout << "Bidirectional iterator is used" << std::endl;
}

template <class ForwIt>
void test(ForwIt a, std::forward_iterator_tag)
{
    std::cout << "Forward iterator is used" << std::endl;
}

template <class Iter>
void test(Iter a)
{
    test(a, typename std::iterator_traits<Iter>::iterator_category());
}

فئات المكرِّرات هي في الأساس مفاهيم مُكرّرات، باستثناء أنّ المكرّرات المتجاورة (Contiguous Iterators) ليس لها وسم (tag) خاص بها، إذ أنها مُخصّصة لإيقاف الشيفرة (break code).

المُكرِّر المُتّجِهي (Vector Iterator)

تعيد begin مكرّرًا iterator يشير إلى العنصر الأول في حاوية التسلسل (sequence container)، بينما تعيد end مكرّرًا يشير إلى العنصر الأول بعد النهاية.

إذا كان الكائن المتّجهي (vector object) ثابتًا const فإنّ كلًّا من begin و end ستعيدان مُكّررًا ثابتًا const_iterator، وإن أردت أن يُعاد مكرّر ثابت حتى لو لم تكن المتجهة ثابتة، فاستخدم cbegin و cend. انظر المثال التالي حيث نهيئ متجهًا باستخدام initializer_list:

#include <vector>
#include <iostream>
int main()
{
    std::vector<int> v = {1, 2, 3, 4, 5};
    for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it)
    {
        std::cout << *it << " ";
    }
    return 0;
}

سيكون الخرج:

1 2 3 4 5 

مكرّرات القواميس map_iterator

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

std::map<char, int> mymap;
mymap['b'] = 100;
mymap['a'] = 200;
mymap['c'] = 300;
for (std::map<char, int>::iterator it = mymap.begin(); it != mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

سيكون الخرج:

a => 200
b => 100
c => 300 

المكرِّرات العكسيّة (Reverse Iterators)

تُستخدم المكررات العكسية reverse_iterator عندما نريد أن نحرِّك المكرِّر للخلف خلال قائمة أو متجه، ونحصل على تلك المكررات من مكرر ثنائي الاتجاه أو مكرر عشوائي، وهما يحتفظان بذلك المكرر كعضو يمكن الوصول إليه من خلال التابع base()‎. ولكي يتحرّك المُكرِّر للخلف، عليك استخدام rbegin()‎ و rend()‎ كمكرّرين يشيران إلى نهاية وبداية المجموعة على الترتيب. انظر المثال التالي الذي نكرر فيه إلى الخلف لنطبع (54321):

std::vector<int> v{1, 2, 3, 4, 5};
for (std::vector<int>::reverse_iterator it = v.rbegin(); it != v.rend(); ++it)
{
    cout << *it;
}

كذلك يمكن تحويل مكرّر عكسي إلى مكرّر أمامي من خلال التابع base()‎، ويشير المكرّر العكسي إلى العنصر الذي يلي المكرّر base()‎، انظر المثال التالي حيث تكون assert(&*r == &*(i-1));‎ صحيحة إن كان r و (i-1) يقبلان التحصيل (Dereferencing) ولم يكونا مكرريْن وكيلين (Proxy Iterators).

std::vector<int>::reverse_iterator r = v.rbegin();
std::vector<int>::iterator i = r.base();
assert(&*r == &*(i-1)); 
+----+---+---+---+---+---+---+
|      |  1 |  2 |  3 |  4 |  5 |    |
+----+---+---+---+---+---+---+
  ↑      ↑                     ↑    ↑
  |       |                      |     |
rend()  |              rbegin()     end()
          |                                  rbegin().base()
        begin()
       rend().base()

ستكون العلاقة أبسط إن عدنا إلى التصور السابق حيث تحدِّد المكرراتُ المواضع بين العناصر، انظر:

+---+---+---+---+---+
|  1 |  2 |  3 |  4 |  5 |
+---+---+---+---+---+
↑                           ↑
|                            |
|                        end()
|                       rbegin()
begin()              rbegin().base()
rend()
rend().base()

مُكرِّر التدفق istream_iterator

مُكرِّرات التدفق مفيدة عندما نحتاج إلى قراءة تسلسل أو طباعة بيانات منسّقة (formatted) من الحاوية، لنضرب مثلًا ببرنامج يطبع أرقامًا صحيحة تفصل بين كل منها فاصلتين متتاليتين --، ولنفصله جزءًا جزءًا للتوضيح، فأول جزء يوضح تدفقًا للبيانات، يكون أي عدد من محارف المسافات البيضاء فيه مقبولًا.

std::istringstream istr("1\t 2     3 4");
std::vector < int > v;

نبني الآن مكررات تدفق وننسخ البيانات من التدفق إلى متجه:

std::copy( 

ونستخدم مكررًا يقرأ بيانات التدفق كأعداد صحيحة:

std::istream_iterator < int > (istr),

ينتج الباني الافتراضي مكررًا يشير إلى نهاية التدفق:

std::istream_iterator < int > (),
std::back_inserter(v));

نطبع الآن محتوى المتجه الذي سيكون في مجرى الدخل القياسي كأعداد صحيحة مفصولة بفاصلتين متتاليتين (--):

std::copy(v.begin(), v.end(),
std::ostream_iterator < int > (std::cout, " -- "));

انظر الآن الشيفرة كاملة دون التعليقات التوضيحية:

std::istringstream istr("1\t 2     3 4");
std::vector<int> v;
std::copy(
    std::istream_iterator<int>(istr),
    std::istream_iterator<int>(),   
    std::back_inserter(v));
std::copy(v.begin(), v.end(),
    std::ostream_iterator<int>(std::cout, " -- "));

ويكون الناتج المطبوع للبرنامج أعلاه هو التالي:

1 -- 2 -- 3 -- 4 --

مكرِّرات C (المؤشرات)

انظر المثال التالي لشيفرة ستُنتج الأرقام من 1 إلى 5 بحيث تطبع كل رقم على سطر منفصل:

const int array[] = {1, 2, 3, 4, 5};
#ifdef BEFORE_CPP11

const int *first = array;
const int *afterLast = first + sizeof(array) / sizeof(array[0]);

for (const int *i = first; i < afterLast; ++i)
{
   std::cout << *i << std::endl;
}
#else

for (auto i = std::begin(array); i != std::end(array); ++i)
{
   std::cout << *i << std::endl;
}
#endif

الناتج:

1
2
3
4
5

تحليل الشيفرة

const int array[] = { 1, 2, 3, 4, 5 };

ينشئ السطر السابق مصفوفة أعداد صحيحة (integer) فيها خمس قيَم، تذكر أن مصفوفات لغة C هي مجرد مؤشرات إلى مواضع في الذاكرة حيث تُخزَّن قيم المصفوفة بشكل متجاور.

const int* first = array;
const int* afterLast = first + sizeof(array) / sizeof(array[0]);

هذان السّطران ينشئان مؤشّريْن اثنين، وقد أعطينا للمؤشر الأول قيمة مؤشّر المصفوفة array الذي يمثّل عنوان العنصر الأول فيها. ويعيد العامل sizeof حجم المصفوفة بالبايت عند استخدامه على مصفوفة في لغة C، وعندما نقسمه على حجم عنصر من المصفوفة سنحصل على عدد العناصر في المصفوفة، ومن ثم نستخدم ذلك لإيجاد عنوان الكتلة التالية للمصفوفة في الذاكرة.

for (const int* i = first; i < afterLast; ++i) { 

في السّطر السابق أنشأنا مؤشرًا لاستخدامه كمكرّر، وقد هيّأناه عند عنوان العنصر الأول الذي نريد أن نبدأ التكرار منه، وسنستمر في التكرار ما دام i أصغر من afterLast، أي طالما يشير i إلى عنوانٍ داخل المصفوفة array.

std::cout << *i << std::endl; 

أخيرًا، يمكننا الوصول إلى القيمة التي يشير إليها المُكرِّر i من خلال تحصيله، وذلك داخل الحلقة التكرارية. وهنا يعيد عاملُ التحصيل‏‏ * القيمةَ المخزّنة في العنوان i.

اكتب مُكرِّرك الخاص

يسود في لغات البرمجة الأخرى غير C++ أن توجد دالة تنتج تدفقًا (stream) من الكائنات مع استخدام حلقات تكرارية للمرور على عناصر ذلك التدفق، ويمكن تنفيذ ذلك في C++ أيضًا، انظر المثال التالي حيث نفصل عملية كتابة مكرر خاص بنا:

template < class T >
    struct generator_iterator {
        using difference_type = std::ptrdiff_t;
        using value_type = T;
        using pointer = T * ;
        using reference = T;
        using iterator_category = std::input_iterator_tag;
        std::optional < T > state;
        std:: function < std::optional < T > () > operation;

والآن سنخزن العنصر الحالي -إن كان موجودًا- في state:

        T operator * () const {
            return *state;
        }

نكمل الآن بأن نستدعي العملية، ونكون قد وصلنا للنهاية إن أعادت nullopt:

        generator_iterator & operator++() {
            state = operation();
            return *this;
        }
        generator_iterator operator++(int) {
            auto r = * this;
            ++( * this);
            return r;
        }

لا يتساوى مكرران مدعومان بالمولِّدات (Generator Iterators) إلا إن كانا في حالة end.

        friend bool operator == (generator_iterator
            const & lhs, generator_iterator
            const & rhs) {
            if (!lhs.state && !rhs.state) return true;
            return false;
        }
        friend bool operator != (generator_iterator
            const & lhs, generator_iterator
            const & rhs) {
            return !(lhs == rhs);
        }

سننشئ دالة بشكل مباشر من std::function مع إعطائها البصمة المناسبة.

generator_iterator( std::function< std::optional() > f ):operation(std::move(f)) 
{ 
if (operation)
                state = operation();
} 

نهيئ كل دوال التوابع الخاصة إلى القيمة default.

 generator_iterator( generator_iterator && ) =default;
 generator_iterator( generator_iterator const& ) =default;
 generator_iterator& operator=( generator_iterator && ) =default;
 generator_iterator& operator=( generator_iterator const& ) =default;
 generator_iterator() =default;
};

يمكنك مشاهدة هذا المثال الحيّ. كذلك فإننا سنخزّن العنصر المُنشأ مبكرًا لمعرفة إن كنا وصلنا للنهاية أم لا، ونظرًا لعدم استخدام الدالة الخاصّة بمكرر المولِّد النهائي (end generator iterator)، فنستطيع إنشاء مجموعة من مكررات المولدات عن طريق نسخ std::function مرة واحدة فقط، ويكون مكرر المولد المنشأ افتراضيًا مساويًا لنفسه ولجميع مكررات المولدات النهائية.

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

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

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

تهيئة المصفوفة

المصفوفة هي كتلة مكوّنة من مواقع متسلسلة في الذاكرة والمخصصة لنوع معيّن من المتغيرات. تخصيص المصفوفات يشبه تخصيص المتغيرات العادية، ولكن مع إضافة قوسين مربّعين إلى اسمها [] يحتويان على عدد يمثل عدد العناصر التي يمكن أن تحتويها ذاكرة المصفوفة.

يستخدم المثال التالي مصفوفة تستخدم نوع int، واسم المتغير arrayOfInts، وعدد عناصرها هو [ 5 ]:

int arrayOfInts[5];

يمكن التصريح عن المصفوفة وتهيئتها في نفس الوقت على النحو التالي:

int arrayOfInts[5] = {10, 20, 30, 40, 50};

إذا هيّأت مصفوفة بسرد جميع عناصرها فلا يلزمك تضمين عدد عناصر المصفوفة داخل القوسين المعقوفين، إذ سيحسُبه المُصرّف تلقائيًا. في المثال التالي، تعداد المصفوفة هو 5:

int arrayOfInts[] = {10, 20, 30, 40, 50};

كذلك نستطيع تهيئة العناصر الأولى فقط، مع تخصيص مساحة للمزيد من العناصر، وفي هذه الحالة يلزمك كتابة طول المصفوفة بين القوسين المعقوفين. انظر الشيفرة التالية حيث نخصص مصفوفةً خماسية (تحتوي 5 عناصر) مع تهيئتها جزئيًّا، سيُهيّئ المصرّف بقية العناصر بالقيمة الافتراضية لنوع العنصر (في هذه الحالة، تلك القيمة هي 0).

int arrayOfInts[5] = {10,20};    

أي أن عناصر المصفوفة السابقة هي (10, 20, 0, 0, 0). كذلك يمكن تهيئة مصفوفات أنواع البيانات الأساسية الأخرى بالطريقة نفسها. انظر المثال التالي للتصريح عن مصفوفة وتخصيص مساحة ذاكرة لها دون تهيئتها:

char arrayOfChars[5];

أو للتصريح عنها مع تهيئتها:

char arrayOfChars[5] = { 'a', 'b', 'c', 'd', 'e' } ; 
double arrayOfDoubles[5] = {1.14159, 2.14159, 3.14159, 4.14159, 5.14159};
string arrayOfStrings[5] = { "C++", "is", "super", "duper", "great!"};

لاحظ أنه عند الوصول إلى عناصر المصفوفة فإن فهرس المصفوفة (أو موضعها) يبدأ عند القيمة 0. انظر المثال التالي، حيث يكون العنصر 10 هو العنصر رقم 0، و20 هو العنصر رقم 1، وهكذا.

int array[5] = { 10, 20, 30, 40, 50};
std::cout << array[4]; // 50
std::cout << array[0]; // 10

المصفوفات متعددة الأبعاد ذات الحجم الثابت

يشير الفهرس m[y]‎ في المثال أدناه إلى الصف رقم yمن المصفوفة m، حيث y مؤشرٌ يبدأ من الصفر، ويمكن فهرسة هذا الصف على النحو التالي my ‎ والذي يشير إلى العنصر/العمود x من الصف y، وذلك يعني أن الفهرس الأخير هو الأسرع تغيرًا، ونطاقه في التصريح -حيث النطاق هنا هو رقم الأعمدة لكل صف- هو آخر و"أعمق" حجم محدَّد.

#include <iostream>
#include <iomanip>
using namespace std;

auto main() -> int
{
    int const n_rows = 3;
    int const n_cols = 7;
    int const m[n_rows][n_cols] = 
    {
        { 1, 2, 3, 4, 5, 6, 7 },
        { 8, 9, 10, 11, 12, 13, 14 },
        { 15, 16, 17, 18, 19, 20, 21 },
    };

    for( int y = 0; y < n_rows; ++y )
    {
        for( int x = 0; x < n_cols; ++x )
        {
 // m[y,x] لا تستخدم
            cout << setw( 4 ) << m[y][x];
        }
        cout << '\n';
    }
}

يكون الناتج:

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 

لا تدعم C++‎ صياغة خاصة لفهرسة المصفوفة متعددة الأبعاد، وإنما تتعامل معها على أنها مصفوفة مكونة من مصفوفات أخرى داخلها، وتستخدم الفهرسة العادية لكل مستوى.

وبما أن C++‎ لا توفر دعمًا بشكل افتراضي للمصفوفات ذات الحجم المتغير أو المصفوفات الديناميكية (Dynamic Size Arrays) ما عدا التخصيص الديناميكي (Dynamic Allocation)، فإن المصفوفة الديناميكية تُستخدم غالبًا كصنف (Class).

لكن هناك بعض التعقيدات المرتبطة بصياغة الفهرسة m[y][x]‎، إما بكشف الاستخدام ليستحيل عرض منقول المصفوفة مثلًا (Transposed Matrix) أو بإضافة حمل زائد على البرنامج عند تنفيذه بإعادة كائن وكيل (Proxy Object) من عامل الفهرسة operator[OD1][]‎، وعليه قد تكون صياغة الفهرسة مختلفة سواء في الشكل أو في ترتيب الفهارس، كما هو الحال في m(x,y)‎ أو m.at(x,y)‎ أو m.item(x,y)‎.

المصفوفات الديناميكية (Dynamically sized raw array)

انظر المثال التالي كمثال على مصفوفة ديناميكية، واعلم أن الأفضل عمومًا هو استخدام std::vector:

#include <algorithm>            // std::sort
#include <iostream>
using namespace std;

auto int_from( istream& in ) -> int { int x; in >> x; return x; }
auto main()
       -> int
{
    cout << "Sorting n integers provided by you.\\n";
cout << "n? ";
int const n = int_from( cin );
// n تخصيص مصفوفة عدد عناصرها 
int* a = new int[n];

     for( int i = 1; i <= n; ++i )
{
cout << "The #" << i << " number, please: ";
a[i-1] = int_from( cin );
}
sort( a, a + n );
for( int i = 0; i < n; ++i ) { cout << a[i] << ' '; }
cout << '\\n';

delete[] a;    
}

في بعض المُصرِّفات التي تدعم المصفوفات ذات الطول المتغير وفق معيار C99 ‏(variadic length arrays أو VLAs) كإضافة للّغة، يمكن تصريف برنامج يعلن عن مصفوفة T a[n];‎، حيث لا تُحدَّد n حتى وقت التشغيل (run-time). لكنّ C++‎ القياسية لا تدعم تلك المصفوفات، لذا يمكن استخدام تعبير new[]‎ لتخصيص مصفوفة ديناميكية بشكل يدوي، انظر المثال التالي حيث نخصص مصفوفة مكونة من n عنصر:

int*   a   = new int[n]; 

تستطيع إلغاء تخصيص المصفوفة بعد استخدامها عبر delete[]‎:

delete[] a;

قيم المصفوفة التي صرّحنا عنها أعلاه غير محددة، ولكن يمكن تهيئة عناصرها عند القيمة صفر عبر إضافة قوسين فارغين () هكذا: new int[n]()‎، وعمومًا فإنه لأي نوع من أنواع البيانات، يهيئ هذا التعبير قيمَ المصفوفة بالقيمة الافتراضية لذلك النوع.

لن تكون هذه الشيفرة آمنة للتنفيذ كجزء من دالة في أسفل هرمية الاستدعاء، ذلك أنه قد يحدث تسريب للذاكرة في حالة وجود استثناء قبل تعبير delete[]‎‎، (أو بعد ‎new[]‎)، وحل ذلك يكون بأتمتة عملية التنظيف عبر استخدام المؤشر الذكي std::unique_ptr، رغم أن الأفضل هو استخدام متجه (std::vector) إذ تلك هي وظيفته الأساسية.

حجم المصفوفة

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

#include      // size_t, ptrdiff_t
 //-----------------------------------:
using Size = ptrdiff_t;
template < class Item, size_t n >
    constexpr auto n_items(Item( & )[n]) noexcept 
    -> Size 
   { return n; }
//----------------------------------- الاستخدام:
#include
using namespace std;
auto main()
-> int
{
int const a[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 4};
Size const n = n_items( a );
        Size
        const n = n_items(a);
        int b[n] = {}; // a مصفوفة لها نفس حجم  
        (void) b;
        cout <}

يمكن الحصول على حجم المصفوفة في لغة C عبر: sizeof(a)‎ أو sizeof(a[0])‎، في حال تمرير مؤشر كوسيط، لكن تكون النتيجة بشكل عام غير دقيقة. أما في C++11، يمكنك الحصول على حجم المصفوفة بالتعبير التالي:

std::extent<decltype(MyArray)>::value;

مثال:

char MyArray[] = { 'X','o','c','e' };
const auto n = std::extent<decltype(MyArray)>::value;
std::cout << n << "\n"; // يطبع 4

لم يكن في أي إصدار من C++‎ إلى الإصدار C++17 أي آلية أو مكتبة قياسية مضمَّنة فيها للحصول على أحجام المصفوفات، وإنما نحصل على ذلك بتمرير مرجع يشير للمصفوفة إلى قالب دالة (function template) كما هو موضح أعلاه.

معامل حجم القالب (template size parameter) هو size_t، وهو غير متوافق مع النوع المؤشَّر (signed type) للقيمة المعادة من الدّالة Size، وذلك لأجل التوافق مع المُصرّف g++‎ الذي يصر أحيانًاعلى size_t من أجل مطابقة القوالب. كبديل عن ذلك، يمكن استخدام std::size في C++17 والإصدارات اللاحقة لها، إذ هو تابع مخصص للمصفوفات.

توسيع المصفوفات الديناميكية باستخدام المتجهات

انظر المثال التالي الذي يوضح استخدام متجه std::vector كمصفوفة ديناميكية قابلة للتوسع:

#include <algorithm>            // std::sort
#include <iostream>
#include <vector>               // std::vector
using namespace std;

int int_from( std::istream& in ) { int x = 0; in >> x; return x; } 
int main() 
{     cout << "Sorting integers provided by you.\n";
    cout << "You can indicate EOF via F6 in Windows or Ctrl+D in Unix-land.\n";
    vector < int > a; // ← الحجم يساوي 0 افتراضيا
while( cin ) {
        cout << "One number, please, or indicate EOF: ";
        int const x = int_from( cin );
        if( !cin.fail() ) { a.push_back( x ); }          // التوسيع بحسب الضرورة
    }
    sort( a.begin(), a.end() );
    int const n = a.size();
    for( int i = 0; i < n; ++i ) { cout << a[i] << ' '; }
    cout << '\n';
}

std::vector هو قالب صنف في المكتبة القياسية التي توفر مفهوم المصفوفة ذات الحجم المتغير (الديناميكية)، وتتكفل تلك المكتبة بإدارة الذاكرة، كما أنّ المخزن المؤقت (buffer) متصل (contiguous)، لذا يمكن تمرير مؤشر يشير إلى المخزن المؤقت (على سبيل المثال ‎&v[0]‎ أو v.data()‎) إلى دوال الواجهة البرمجية (API) التي تتطلّب مصفوفةً خام (raw array). يمكن توسيع المتجهة vector في وقت التشغيل عبر التابع push_back الذي يضيف عنصرًا إلى المصفوفة.

يُحدَّد تعقيد سلسلة عمليات push_back عددها n، بما في ذلك عمليات النسخ والنقل المستخدمتين في توسيعات المتجهات، في المتوسط من خلال O(n)، ويُنفّذ ذلك داخليًا عبر مضاعفة حجم المخزن المؤقّت للمتجهة vector وسِعتها عند الحاجة إلى حجم أكبر.

فمثلًا، إذا كان المخزن المؤقّت يبدأ بالحجم 1، ثم يتضاعف حجمه بشكل متكرر حسب الحاجة، فإنّه في مقابل n=17 عملية استدعاءً للتابع push_back، ستكون هناك 1 + 2 + 4 + 8 + 16 = 31 عملية نسخ، أي أقل من 2 × n = 34. لكن بشكل عام فلا يمكن أن يتجاوز مجموع هذا التسلسل القيمة 2 × n.

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

استخدام std::vector في المصفوفة الديناميكية للتخزين

بدءًا من الإصدار C++14 لم يعد هناك أي صنف (Class) مخصص للمصفوفات الديناميكية في المكتبة القياسية، وإنما ستجد مثل تلك الأصناف التي تدعم الحجم المتغير في بعض مكتبات الطرف الثالث، بما في ذلك مكتبة Boost Matrix (مكتبة فرعية داخل مكتبة Boost). وإن لم ترد الاعتماد على Boost أو أيّ مكتبة أخرى، فيمكنك كتابة المصفوفات متعددة الأبعاد الديناميكية في ++C على نحو ما في المثال التالي، حيث vector هي متجهة من النوع std::vector.

vector<vector<int>> m( 3, vector<int>( 7 ) );

تُنشأ المصفوفة هنا عن طريق نسخ متجه صفِّي (row vector) عددًا من المرات قدره n مرة، حيث n هو عدد الصفوف الذي يساوي 3 في مثالنا أعلاه. تمتاز تلك الطريقة بدعمها لصيغة الفهرسة m[y][x]‎ كما في المصفوفة متعددة الأبعاد ثابتة الحجم، لكنها غير فعّالة من جهة أخرى إذ تتطلّب تخصيص ذاكرة ديناميكيّ لكل صفّ، كما أنّها غير آمنة بسبب إمكانية تغيير حجم الصف عن غير عمد.

وعلى أي حال توجد طريقة أخرى أفضل وهي استخدام متجه واحد كتخزين للمصفوفة، وتوجيه شيفرة العميل (x,y) إلى فهرس مناسب في ذلك المتجه. انظر المثال التالي لمصفوفة متغير الحجم (ديناميكية) تستخدم std::vector للتخزين:

//--------------------------------------------- الألية:
#include // std::copy
#include // assert
#include // std::initializer_list
#include // std::vector
#include // ptrdiff_t
namespace my
{
   using Size = ptrdiff_t;
   using std::initializer_list;
   using std::vector;
   template <class Item>
   class Matrix
   {
   private:
       vector items_;
       Size n_cols_;
       auto index_for(Size const x, Size const y) const
           -> Size
       {
           return y * n_cols_ + x;
       }

   public:
       auto n_rows() const -> Size { return items_.size() / n_cols_; }
       auto n_cols() const -> Size { return n_cols_; }
       auto item(Size const x, Size const y)
           -> Item &
       {
           return items_[index_for(x, y)];
       }
       auto item(Size const x, Size const y) const
           -> Item const &
       {
           return items_[index_for(x, y)];
       }
       Matrix() : n_cols_(0) {}
       Matrix(Size const n_cols, Size const n_rows)
           : items_(n_cols * n_rows), n_cols_(n_cols)
       {
       }
       Matrix(initializer_list<initializer_list> const &values)
           : items_(), n_cols_(values.size() == 0 ? 0 : values.begin()->size())
       {
           for (auto const &row : values)
           {
               assert(Size(row.size()) == n_cols_);
               items_.insert(items_.end(), row.begin(), row.end());
           }
       }
   };
} // namespace my
//--------------------------------------------- الاستخدام:
using my::Matrix;
auto some_matrix()
   -> Matrix
{
   return {
       {1, 2, 3, 4, 5, 6, 7},
       {8, 9, 10, 11, 12, 13, 14},
       {15, 16, 17, 18, 19, 20, 21}};
}

#include
#include
using namespace std;
auto main() -> int
{
   Matrix const m = some_matrix();
   assert(m.n_cols() == 7);
   assert(m.n_rows() == 3);
   for (int y = 0, y_end = m.n_rows(); y < y_end; ++y)
   {
       for (int x = 0, x_end = m.n_cols(); x < x_end; ++x)
       {
           cout <← Note : not `m[y][x]`!
       }
       cout <
   }
}

يكون الخرج:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 

الشيفرة أعلاه ليست مناسبة لا توافق معايير بيئات الإنتاج في الشركات، وإنما صُممت لتوضيح المبادئ الأساسية وخدمة احتياجات الطلاب الذي يتعلمون C++‎، فمثلًا يمكن تحديد التحميل الزائد لـ ()operator لتبسيط صيغة الفهرسة.

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

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

تصفير البت الأيمن (Rightmost set bit)

ملاحظة: المقصود بتصفير بت أي جعل قيمته 0، والمقصود بتعيين قيمة بت أي جعل قيمته 1.

معالجة البتات وفق أسلوب لغة C

template < typename T >
    T rightmostSetBitRemoved(T n) {
  
        // وما بعدها c++11 لأجل
        // static_assert(std::is_integral<T>::value && !std::is_signed<T>::value, "type should   //be unsigned"); 
        return n & (n - 1);
    }

تفسير المثال

• إذا كان n يساوي الصفر، فسنحصل على ‎0‎ & 0xFF..FF والتي تساوي صفرًا.
• وإن كان غير ذلك فيمكن كتابة n على الصورة 0bxxxxxx10..00، ومن ثم سيُكتب n - 1 على الصورة 0bxxxxxx011..11. وهكذا، فإنّ n & (n - 1)‎ ستساوي 0bxxxxxx000..00.

ضبط كل البتات إلى القيمة 1 (Set all bits)

معالجة البتات وفق أسلوب لغة C

x = -1; // -1 == 1111 1111 ... 1111b

(انظر هذه الصفحة الأجنبية للمزيد من التفاصيل).

استخدام std::bitset

std::bitset<10> x;
x.set(); // إسناد القيمة 1 إلى كل البتات 

تبديل قيمة بت

معالجة البتات وفق أسلوب لغة C

يمكن تبديل قيمة البت باستخدام معامِل XOR الثنائي (^) .

// عكس قيمتها الحالية x ستصبح قيمة البت.
number ^= 1LL << x;

استخدام std::bitset

std::bitset<4> num(std::string("0100"));
num.flip(2); // num = 0000
num.flip(0); // num = 0001
num.flip(); // يبدل جميع البتّات ،num = 1110

التحقق من قيمة البت

معالجة البتات وفق أسلوب لغة C

يمكن الحصول على قيمة بت معيّنة في التمثيل الثنائي لعدد ما عن طريق إزاحته إلى اليمين بمقدار x - إذ x تشير إلى عدد المرات-، ثم تنفيذ عملية AND الثنائية & عليه:

(number >> x) & 1LL; 
// تساوي 1، وإلا فسَيساوي 0 x الناتج سيساوي 1 في حال كانت البت رقم

يمكن تنفيذ عملية الإزاحة اليمينية (right-shift operation) إما كإزاحة حسابية مُؤشرَّة (arithmetic signed shift) أو كإزاحة منطقية غير مؤشرة (logical unsigned shift). إن كان number في التعبير number >> x ذا نوعٍ مُؤشَّر (signed type) وله قيمة سالبة، فإنّ القيمة الناتجة تحدد وفق التطبيق (implementation-defined).

وإن أردنا الحصول على قيمة تلك البت مباشرة في موضعها فيمكننا إزاحة القناع لليسار:

(number & (1LL << x)); 

 الناتج سيساوي ‎1 >> x  في حال كان البت رقم 1 يساوي 1 وإلا فسيساوي الصفر. يمكننا استخدامهما كشرط لأنّ جميع القيم المخالفة للصفر تُعدُّ صحيحة.

استخدام std::bitset

std::bitset<4> num(std::string("0010"));
bool bit_val = num.test(1); // true تساوي bit_val قيمة

عدّ البتات ذات القيمة 1

تزيد الحاجة لعد البتات الموجودة في سلسلة بتية (Bitstring) في علم التشفير وغيره، وقد دُرست تلك المشكلة على نطاق واسع، والطريقة البسيطة لعدها هي المرور على البتات فرادى:

// n مراكمة العدد الإجمالي للوحدات في التمثيل الثنائي للعدد
unsigned value = 1234;
unsigned bits = 0; 

for (bits = 0; value; value >>= 1)
bits += value & 1;

بيْد أنّ هذه الطريقة أفضل (تعتمد على إزالة البت الأيمن ذا القيمة 1):

// n تراكم إجمالي عدد البتّات في التمثيل الثنائي للعدد
unsigned bits = 0;

for (; value; ++bits)
   value &= value - 1;

تُنفِّذ الشيفرة أعلاه عددًا من التكرارات يكافئ عدد البتات التي تأخذ القيمة 1، لذا فهي مناسبة إن كان في value عدد قليل من البتات غير الصفرية (non-zero bits).

تم اقتراح هذه الطريقة للمرة الأولى من طرف بيتر فيجنيور (Peter Wegner) في عام CACM 3/322 - 1960، وقد لقيت قبولًا وتبنيًا كثيرًا منذ ظهورها في كتاب لغة البرمجة C الذي كتبه برايان كرنيجن ودينيس ريتشي. وتتطلب تلك الطريقة 12 عملية حسابية، إحداها عملية متعددة:

unsigned popcount(std::uint64_t x) {
    const std::uint64_t m1 = 0x5555555555555555; // binary: 0101...
    const std::uint64_t m2 = 0x3333333333333333; // binary: 00110011..
    const std::uint64_t m4 = 0x0f0f0f0f0f0f0f0f; // binary: 0000111100001111
  	
  	// وضع تعداد كل بتّيْن في هاتين البتّيْن
    x -= (x >> 1) & m1;
  
  	// وضع تعداد كل 4 بتات في تلك البتات الأربعة
    x = (x & m2) + ((x >> 2) & m2);
  
  	//  وضع تعداد كل 8 بتات في تلك البتات الثمانية
    x = (x + (x >> 4)) & m4;
  
  	// ... + (x<<24) + (x<<16) + (x<<8) + x البتات الثمانية على يسار
    return (x * h01) >> 56; 
}

هذا النوع من التطبيق لديه أفضل سلوك للحالة الأسوأ (Worst-Case) انظر Hamming weight لمزيد من التفاصيل. يحتوي العديد من وحدات المعالجة المركزية CPUs على تعليمات محددة (مثل popcnt في x86)، ويمكن للمصرّف إنشاء دالة مخصصة (غير قياسية) مضمنة، فمثلًا في مصرّف ++g نجد التعليمة التالية‎:

int __builtin_popcount (unsigned x);

التحقق مما إذا كان عدد صحيح ما هو أس للعدد 2

تُعد طريقة n & (n - 1)‎ المُستعملة في مقالة إزالة بت التعيين اليمنى مفيدة لتحديد ما إذا كان عدد صحيح هو أس للرقم 2:

bool power_of_2 = n && !(n & (n - 1));

لاحظ أنه بدون الجزء الأول من عملية التحقق (n &&)، فسيُعد العدد 0 أسًّا للرقم 2، وذلك خطأ.

تعيين بت محدَّد

معالجة البتات وفق أسلوب لغة C

يمكن تعيين قيمة بت باستخدام عامل OR الثنائي (|).

// x تعيين قيمة البت رقم
number |= 1LL << x;

استخدام std::bitset

التعبير set(x)‎ أو ‎set (x, true)‎‎ يُسنِد القيمة 1 إلى البت الموجودة في الموضع x.

std::bitset<5> num(std::string("01100"));
num.set(0); // num = 01101
num.set(2); // 01101 يساوي num لا يزال
num.set(4,true); // 11110 يساوي الآن num

تصفير بت محدَّد

معالجة البتات وفق مقاربة لغة C

يمكن تصفير (إعطاء القيمة 0) بت محدَّد باستخدام معامِل AND الثنائي (&).

// x مسح البت الموجودة عند الموضع
number &= ~(1LL << x);

استخدام std::bitset

تصفر التعليمة reset(x)‎ أو ‎set (x, false))‎‎ يمسح البت الموجودة في الموضع x.

std::bitset<5> num(std::string("01100"));
num.reset(2); // 01000  يساوي الآن  num
num.reset(0); // 01000  يساوي الآن  num
num.set(3,false); // 00000  يساوي الآن  num

تغيير قيمة البت رقم n إلى x

معالجة البتات وفق أسلوب لغة C

في المثال التالي، ستضبط قيمة البت رقم  n إلى القيمة 1 في حال كانت قيمة x تساوي 1 وستُصفَّر قيمتها في حال كانت قيمة x يساوي الصفر:

number ^= (-x ^ number) & (1LL << n);

استخدام std::bitset

تعين التعليمة set(n,val)‎ يعين القيمة val للبتّة n.

std::bitset<5> num(std::string("00100"));
num.set(0,true); // 00101 يساوي الآن num
num.set(2,false); // 00001 يساوي الآن num

تطبيق على معالجة البتات: تغيير حالة الحروف

أحد التطبيقات على معالجة البتات والتلاعب بها هو تحويل الحروف الأجنبية من الحالة الصغرى (Small) إلى الحالة الكبرى (Capital) أو العكس، عن طريق اختيار قناع (mask) و عملية ثنائية (bit operation) مناسبة. فمثلًا، يكون التمثيل الثنائي للحرف a هو ‎01(1)00001، وللحرف A هو 01‎(0)00001‎. لا يختلف التمثيلان السابقان إلا في البت الموجودة بين القوسين. لذا فإنّ تحويل الحرف a من الحالة الصغرى إلى الحالة الكبرى يكافئ تعيين البت الموجودة بين قوسين على القيمة 1 على النحو التالي:

/****************************************
تكبير حرف صغير
========================================
a: 01100001
mask: 11011111  <-- (0xDF)  11(0)11111
:---------
a&mask: 01000001  <-- A الحرف
*****************************************/

شيفرة تكبير الحرف A هي:

#include <cstdio>

int main() {
    char op1 = 'a'; // "a" الحرف
    int mask = 0xDF; // اختيار قناع مناسب
  
    printf("a (AND) mask = A\n");
    printf("%c   &   0xDF = %c\n", op1, op1 & mask);

    return 0;
}

النتيجة:

$ g++ main.cpp -o test1
$ ./test1
a (AND) mask = A
a   & 0xDF = A

حقول البتات

تحزِّم حقولُ البتات (Bit fields) بُنيات C و C++‎ لتصغير حجمها، إذ تحدد عدد البتات المخصصة لأعضاء البنية، ثم يدمج المصرّف (co-mingle) البتّات. السيء في هذا هو أنك لن تستطيع تحديد عنوان حقل البتة الخاص بعضو معين من البنية لأن المصرّف يدمجهما معًا. كذلك فإن الدالة sizeof()‎ غير مسموح بها.

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

إليك المثال التالي لتوضيح كيفية التصريح والاستخدام:

struct FileAttributes {
    unsigned int ReadOnly: 1;
    unsigned int Hidden: 1;
};

في هذا المثال، سيشغل كلّ حقل من هذين الحقلين بتّة واحدة في الذاكرة، وعلامة ذلك العدد 1 الموجود بعد أسماء المتغيّرات.

يمكن أن يكون حقل البتات من أيّ نوع عددي صحيح (من ‎8-bit int وحتى ‎64-bit‎ int‎). يُستحسن استخدام النوع unsigned، وإلا فقد تحصل على نتائج غير متوقعة. إذا كانت هناك حاجة إلى المزيد من البتات، فاستبدل "1" بعدد البتات المطلوب. مثلًا:

struct Date {
    unsigned int Year: 13; // 2^13 = 8192
    unsigned int Month: 4; // 2^4 = 16
    unsigned int Day: 5; // 32
};

البنية بأكملها لن تستخدم إلا 22 بت فقط، وفي إعدادات التصريف العادية، سيكون ناتج sizeof الخاص بهذه البنية هو 4 بايتات. استخدام حقول البتات سهل جدّا، فما عليك إلا التصريح عن المتغيّر ثم استخدامه كبنية عادية.

Date d;
d.Year = 2016;
d.Month = 7;
d.Day = 22;

std::cout << "Year:" << d.Year << std::endl <<
    "Month:" << d.Month << std::endl <<
    "Day:" << d.Day << std::endl;

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

ترجمة -وبتصرّف- للفصل Chapter 6: Bit Manipulation من كتاب C++ Notes for Professionals

اقرأ أيضا

• الدرس 5: العمليات البتية

تُنفَّذ العمليات البتية (أو الثنائية) على مستوى البت من البيانات وذلك باستعمال العوامل التالية:

| - عامِل OR البِتِّي (Bitwise OR)

إليك المثال التالي:

int a = 5; // 0101b  (0x05)
int b = 12; // 1100b  (0x0C)
int c = a | b; // 1101b  (0x0D)

std::cout << "a = " << a << ", b = " << b << ", c = " << c << std::endl;

يكون ناتج الشيفرة السابقة هو:

a = 5, b = 12, c = 13

وسبب ذلك أن عامِل OR يعمل على مستوى البِتّْ (bit level)، ويستخدم جدول الصحة البوليني أو المنطقي (Boolean Truth Table) التالي:

true OR true = true
true OR false = true
false OR false = false

عندما يُطبق عامل OR على القيمتين البتّيّتين ‎a ‎ (أي 0101)‎ و ‎b ‎ (أي 1100)‎ ، سنحصل على القيمة البتّيّة 1101:

int a = 0 1 0 1
int b = 1 1 0 0 |
---------
int c = 1 1 0 1

لا يغير عامِل OR القيم الأصلية للمعامَلات إلا في حالة استخدام عامِل الإسناد البِتِّي المركَّب =| (Bitwise Assignment Compound Operator) لإسناد تغيير تلك القيم:

int a = 5; // 0101b  (0x05)
a |= 12; // a = 0101b | 1101b

^ - عامل XOR البِتِّي (Bitwise XOR)

إليك المثال التالي:

int a = 5; // 0101b  (0x05)
int b = 9; // 1001b  (0x09)
int c = a ^ b; // 1100b  (0x0C)

std::cout << "a = " << a << ", b = " << b << ", c = " << c << std::endl;

يكون ناتج الشيفرة السابقة:

a = 5, b = 9, c = 12

وسبب ذلك أن عامِل XOR يعمل على مستوى البِتّْ (bit level)، ويستخدم جدول الصحة البولياني التالي:

true OR true = false
true OR false = true
false OR false = false

لاحظ أنه في عملية XOR، يكون لدينا true XOR true = false، على خلاف العمليتين AND و OR، إذ تحققان: true AND/OR true = true، وذلك هو وصف الطبيعة الحصرية لعملية XOR. عندما يُطبّق عامِل XOR على القيمتين البتّيّتين ‎a ‎ (أي 0101)‎ و ‎b ‎ (أي 1001)‎ ، سنحصل على القيمة البتّيّة 1101:

int a = 0 1 0 1
int b = 1 0 0 1 ^
---------
int c = 1 1 0 0

لا يغير عامِل XOR القيم الأصلية للمعامَلات إلا في حالة استخدام عامِل الإسناد البِتِّي المركَّب =^ (Bitwise Assignment Compound Operator) لإسناد تغيير تلك القيم:

int a = 5; // 0101b  (0x05)
a ^= 9; // a = 0101b ^ 1001b

يمكن استخدام عامِل XOR بعدة طرق، وغالبًا ما يُستخدَم في عمليات البتات المُقنّعة (bit mask operations) لتشفير البيانات وضغطها.

لاحظ أن المثال التالي توضيحي، ولا ينبغي أن يُستخدم في الشيفرة النهائية (هناك طرق أفضل لتحقيق نفس النتيجة، مثل std::swap()‎). تستطيع استخدام عملية XOR لمبادلة متغيرين:

int a = 42;
int b = 64;

// XOR المبادلة عبر
a ^= b;
b ^= a;
a ^= b;

std::cout << "a = " << a << ", b = " << b << "\n";

لإنجاز هذا، تحتاج إلى التحقق من إمكانية استخدامه.

void doXORSwap(int & a, int & b) {
    // ينبغي إضافة عبارة للتحقق من أنك لا تبادل المتغير مع نفسه
    // وإلا ستجعل القيمة صفرية
  
    if ( & a != & b) {
        // XOR مبادلة
        a ^= b;
        b ^= a;
        a ^= b;
    }
}

ورغم أنها تبدو طريقة مناسبة للعزل إلا أنها ليست مفيدة في شيفرة الإنتاج، ذلك أن xor ليس عملية منطقية أساسية، بل مزيج من عمليات أخرى: a^c=~(a&c)&(a|c)‎.

كذلك ، فإن المُصرفات التي صدرت بعد 2015 أتاحت إسناد قيم ثنائية إلى المتغيرات:

int cn=0b0111;

& - عامل AND البتّيّ

إليك المثال التالي:

int a = 6; // 0110b  (0x06)
int b = 10; // 1010b  (0x0A)
int c = a & b; // 0010b  (0x02)

std::cout << "a = " << a << ", b = " << b << ", c = " << c << std::endl;

يكون ناتج الشيفرة السابقة:

a = 6, b = 10, c = 2

وسبب ذلك أن عامل AND يعمل على مستوى البت، ويستخدم جدول الصحة البوليني التالي:

TRUE  AND TRUE  = TRUE
TRUE  AND FALSE = FALSE
FALSE AND FALSE = FALSE

عندما يُطبق عامِل AND على القيمتين البتّيّتين ‎a ‎ (أي 0110)‎ و ‎b ‎ (أي 1010)‎ ، سنحصل على القيمة البتّيّة 0010:

int a = 0 1 1 0
int b = 1 0 1 0 &
---------
int c = 0 0 1 0

لا يغير عامِل AND قيمة المعامَل الأصلي إلا عند استخدام عامِل الإسناد البِتِّي المركب ‎&=‎:

int a = 5; // 0101b  (0x05)
a &= 10; // a = 0101b & 1010b

<< - عملية الإزاحة اليسارية (left shift)

إليك المثال التالي:

int a = 1; // 0001b
int b = a << 1; // 0010b

std::cout << "a = " << a << ", b = " << b << std::endl;

يكون ناتج ذلك هو:

a = 1, b = 2

وتفسير ذلك أن عامِل الإزاحة اليساري يزيح بتَّات القيمة الموجودة على الجانب الأيسر (a) بالعدد المحدد على اليمين (1)، مع ملأ البتات الأقل أهمية (least significant bits) بأصفار، فمثلًا في حال إزاحة قيمة العدد 5 (تمثيله الثنائي 0000 0101) إلى اليسار أربعة منازل (على سبيل المثال ‎5 <<‎4)، سوف نحصل على القيمة 80 (تمثيلها الثنائي 0101 0000). قد تلاحظ أنّ إزاحة قيمة إلى اليسار بمنزلة واحدة يكافئ ضرب تلك القيمة بالعدد 2، على سبيل المثال:

int a = 7;

while (a < 200) {
    std::cout << "a = " << a << std::endl;
    a <<= 1;
}

a = 7;

while (a < 200) {
    std::cout << "a = " << a << std::endl;
    a *= 2;
}

ولكن تجدر الإشارة إلى أنّ عملية الإزاحة اليسارية سوف تزيح جميع البتات إلى اليسار، بما في ذلك بتّ الإشارة، انظر إلى المثال التالي:

int a = 2147483647; // 0111 1111 1111 1111 1111 1111 1111 1111
int b = a << 1; // 1111 1111 1111 1111 1111 1111 1111 1110

std::cout << "a = " << a << ", b = " << b << std::endl;

سيكون الناتج:

a = 2147483647, b = -2

وفي حين أنّ بعض المُصرِّفات ستعيد نتائج قد تبدو متوقعة غير أنه يجب ملاحظة أن إزاحة عددٍ ذا إشارة (signed number) بحيث تتأثر بتة الإشارة (sign bit)، فستكون النتيجة غير محددة (undefined). كذلك في حال كان عدد البتات التي ترغب في إزاحتها عددًا سالبًا، أو كان أكبر من عدد البتات التي يمكن أن يحملها النوع الموجود على اليسار، انظر:

int a = 1;

int b = a << -1; // سلوك غير محدد
char c = a << 20; // سلوك غير محدد

لا تغير الإزاحة البتّيّة اليسارية قيمة المعامَلات إلا في حال استخدام عامِل الإسناد البِتِّي المركب ‎<<=‎:

int a = 5; // 0101b
a <<= 1; // a = a << 1;

>> - الإزاحة اليمينية (right shift)

إليك المثال التالي:

int a = 2;        // 0010b
int b = a >> 1;     // 0001b

std::cout << "a = " << a << ", b = " << b << std::endl;

سيكون الناتج:

a = 2, b = 1

وتفسير ذلك أن عامِل الإزاحة اليميني يزيح بتِّات القيمة الموجودة على الجانب الأيسر (a) بالعدد المحدد على اليمين (1)؛ وتجدر الإشارة إلى أنه رغم أنّ عملية الإزاحة اليمينية قياسية، فإنّ ما يحدث لبتات الإزاحة اليمينية في الأعداد السالبة ذات الإشارة (signed negative number) يختلف بحسب الاستخدام، ومن ثم لا يمكن ضمان كونها قابلة للنقل (portable)، انظر:

int a = -2;
int b = a >> 1; // على المصرّف b تعتمد قيمة

كذلك سيكون ذلك السلوك غير محدد إن كان عدد البتات التي ترغب في إزاحتها سالبًا، على سبيل المثال:

int a = 1;
int b = a >> -1; // سلوك غير محدد

لا يغيّر عامل الإزاحة اليميني قيمة المعامَل الأصلي إلا في حال استخدام عامِل الإسناد البِتِّي المركب ‎>>=‎:

int a = 2; // 0010b
a >>= 1; // a = a >> 1;

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

ترجمة -وبتصرّف- للفصل Chapter 5: Bit Operators من كتاب C++ Notes for Professionals

اقرأ أيضا

• الدرس 6: معالجة البتات والتلاعب بها
• الدرس 4: حسابيّات الأعداد العشرية

يفترض كثير من المبرمجين خطأً أن الشيفرة التالية ستعمل كما هو مخطط لها:

float total = 0;
for (float a = 0; a != 2; a += 0.01f) {
    total += a;
}

إذ يفترض المبرمج المبتدئ أن تلك الشيفرة ستجمع كل الأعداد الموجودة في النطاق المحصور بين 0، 0.01، 0.02، 0.03، … ، 1.97، 1.98، 1.99، للحصول في النهاية على 199 كنتيجة، وهي الإجابة الصحيحة. لكن لا يحدث ذلك لسببين:

1. لن ينتهي البرنامج أبدًا بهيئته الحالية، لأنّ a لن تساوي أبدًا القيمة 2، والحلقة التكرارية لن تنتهي.
2. إذا عدّلنا شرط الحلقة التكرارية وجعلناه a < 2، فإنّ الحلقة التكرارية ستنتهي، لكن الإجمالي سيكون شيئًا غير 199 التي نريدها، وعلى الأغلب ستحصل على 201 على الأجهزة المتوافقة مع معيار IEEE754.

سبب حدوث ذلك هو أنّ الأعداد العشرية (Floating Point Numbers) تمثِّل القيم بشكل تقريبي وحسب. كما في المثال التالي:

    double a = 0.1;
    double b = 0.2;
    double c = 0.3;

    if (a + b == c)
        // IEEE754 لن يُطبع هذا على الأجهزة المتوافقة مع 
        std::cout << "This Computer is Magic!" << std::endl;
    else
        std::cout << "This Computer is pretty normal, all things considered." << std::endl;

برغم أننا كمبرمجين نرى ثلاثة أعداد مكتوبة وفق النظام العشري، إلا أن المصرِّف (Compiler) -والحاسوب الذي يعمل عليه- لا يرى إلا أرقامًا ثنائية، لذا يجب أن تخزَّن تلك الأعداد في صيغ تقريبية غير دقيقة كما في حالة العدد 1/3 إذ يخزن على الصورة 0.3333333333 في النظام العشري، وذلك لأن 0.1 و 0.2 و 0.3 تتطلب قسمة تامة على 10، وهذا يسير في النظام العشري لكنه مستحيل في النظام الثنائي.

    // الأعداد العشرية في نظام 64-بت لديها 53 خانة رقمية، بما في ذلك الجزء الصحيح من العدد
    double a = 0011111110111001100110011001100110011001100110011001100110011010;

    // تمثيل تقريبي للعدد 0.1
    double b = 0011111111001001100110011001100110011001100110011001100110011010;

    // تمثيل تقريبي للعدد 0.2
    double c = 0011111111010011001100110011001100110011001100110011001100110011;

    // تمثيل تقريبي للعدد 0.3
    double a + b = 0011111111010011001100110011001100110011001100110011001100110100;
    // 0.3 لاحظ أن هذا العدد لا يساوي

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

ترجمة -وبتصرّف- للفصل Chapter 4: Floating Point Arithmetic من كتاب C++ Notes for Professionals

اقرأ أيضًا

• الدرس 5: العمليات البتِّيّة (Bit Operators)
• الدرس 3: أسبقية العمليات

العمليات المنطقية

العامل المنطقي && له الأسبقية على ||، وذلك يعني أن الأقواس توضع لتقييم ما سيتم تقييمه مع غيره، وتستخدم C++‎ تقييم الدارة القصيرة (short-circuit evaluation) في تقييم && و || من أجل تجنّب إجراء العمليات غير الضرورية. أيضًا، إذا أعاد الجانب الأيسر من || القيمة true، فلن تكون هناك حاجة إلى تقييم الجانب الأيمن.

في المثال التالي، سنقيّم ثلاثة قيم منطقية بالعامِليْن || و && من أجل توضيح الأسبقية، لا تعني الأسبقية أن && ستقيَّم أولًا وإنما توضح أين ستوضع الأقواس:

#include <iostream>
#include <string>

using namespace std;

bool True(string id) {
    cout << "True" << id << endl;
    return true;
}

bool False(string id) {
    cout << "False" << id << endl;
    return false;
}

int main() {
    bool result;

    // حالة 1
    result =
        False("A") || False("B") && False("C"); 
  		// eq. False("A") || (False("B") && False("C"))
    //FalseA
    //FalseB


	// حالة 2
    result =
        True("A") || False("B") && False("C");
                // eq. True("A") || (False("B") && False("C"))
  
    cout << result << " :=====================" << endl;
    //TrueA
}

في تقييم الدارة القصيرة، يجري تخطي C في الحالة الأولى، فبما أن A خطأ فيجب تقييم الجانب الأيمن من العامِل ||؛ تكون B خطأ أيضًا، لذا ليس هنالك حاجة إلى تقييم  C مهما كان تقييمها سواءً خطأ False أم صحيح True.

في الحالة الثانية، يجري تخطي B و C وفقًا لتقييم الدارة القصيرة، إذ قيمة A هي True صحيحة فلا داع لتقييم الجانب الأيمن من المعامل ||. إن كان للعامِل || أسبقية على && فإن التقييم المكافئ يكون: (True("A") || False("B")) && False("C") والذي سيطبع TrueA للجزء الأول الموضوع بين أقواس والذي سيتخطى B فقط آنذاك في تقييم الدارة القصيرة ولكن بوجود العامل && في الطرف الأيمن من الأقواس، ستكون النتيجة النهائية FalseC. بما أنّ الأقواس موضوعة بشكل مختلف، فإنّ الأجزاء التي ستُقيّم ستكون مختلفة ما يجعل النتيجة النهائية في هذه الحالة هي False، لأن تقييم C هو False.

العاملان AND و OR لهما الأسبقية المعتادة في C++‎، أي أنّ AND تسبق OR دومًا.

// يمكنك القيادة برخصة أجنبية لستِّين يوما
bool can_drive = has_domestic_license || has_foreign_license && num_days <= 60;

هذه الشيفرة مكافئة لما يلي:

// يمكنك القيادة برخصة أجنبية لستّين يوما
bool can_drive = has_domestic_license || (has_foreign_license && num_days <= 60);

لا تؤدي إضافة الأقواس إلى تغيير السلوك، ولكنها تحسّن إمكانية القراءة، وترفع اللُّبس عن نية كاتب الشيفرة.

العمليات الأحادية

تُطبَّق العمليات الأحادية على الكائن الذي استُدعيت عليه وسميت أحادية لأن العملية تطبَّق على طرف واحد فقط باستعمال عامل أحادي (Unary Operator)، ولها أسبقية عالية أي تأخذ الأولوية دومًا ضمن المعاملات. عند استخدام العامِل الأحادي بعد الكائن -أي postfix-، فلن يُتَّخذ إجراء إلا بعد تقييم العملية بأكملها، وهذا مفيد في بعض العمليات الحسابية. إليك المثال التالي:

int a = 1;
++a;                // 2
a--;                // 1

int minusa = -a;    // -1
bool b = true;
!b;                 // true

a = 4;
int c = a++/2;      // 4 / 2 = 2
cout << a << endl;  // 5

int d = ++a / 2;    // 6 / 2 = 3

int arr[4] =    {1,2,3,4};

إليك مثال آخر أكثر تتعقيدًا حول تطبيق عملية أحادية باستعمال العامل ++ على المؤشرات:

int arr[4] =    {1,2,3,4};

int * ptr1 = & arr[0];
int * ptr2 = ptr1++;

std::cout << * ptr1++ << std::endl; // 2

// قبل زيادته arr[0] الحصول على قيمة العنصر
int e = arr[0]++;      

std::cout << e << std::endl;        // 1
std::cout << * ptr2 << std::endl;   // 2

يشير المؤشر ptr1 إلى عنوان [arr[0 والتي تخزن القيمة 1 بينما يشير المؤشر ptr2 إلى المؤشر prt1 ثم يزيد من قيمة الأخير مقدار 1 ليشير بذلك إلى العنصر [arr[1.

العمليات الحسابية

العمليات الحسابية في C++‎ لها نفس الأسبقية التي لها في الرياضيات. فعمليتا الضرب والقسمة لهما تجميع يساري (left associativity) -بمعنى أنهما تُقيَّمان من اليسار إلى اليمين-، ولهما أسبقية أعلى من الجمع والطرح، واللتان لهما تجميع يساري كذلك. كما يمكننا أيضًا التحكم في أسبقية التعابير باستخدام الأقواس () كما نفعل في الرياضيات العادية. إليك المثال التالي:

// 4 pi R^3 - 4 pi r^3 = حجم السطح الكروي
double vol = 4.0 * pi * R * R * R / 3.0 - 4.0 * pi * r * r * r / 3.0;

// الإضافة
int a = 2 + 4 / 2;          // =    2+(4/2) = 4
int b = (3 + 3) / 2;        // =    (3+3)/2 = 3

// مع الضرب
int c = 3 + 4 / 2 * 6;      // =    3+((4/2)*6) = 15
int d = 3 * (3 + 6) / 9;    // =    (3*(3+6))/9 = 3

// القسمة والباقي  
int g = 3 - 3 % 1;          // =    3 % 1 = 0  3 - 0 = 3
int h = 3 - (3 % 1);        // =    3 % 1 = 0  3 - 0 = 3
int i = 3 - 3 / 1 % 3;      // =    3 / 1 = 3  3 % 3 = 0  3 - 0 = 3
int l = 3 - (3 / 1) % 3;    // =    3 / 1 = 3  3 % 3 = 0  3 - 0 = 3
int m = 3 - (3 / (1 % 3));  // =    1 % 3 = 1  3 / 1 = 3  3 - 3 = 0

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

ترجمة -وبتصرّف- للفصل Chapter 3: operator precedence من كتاب C++ Notes for Professionals

اقرأ أيضا

• الدرس 4: حسابيات الأعداد العشرية
• الدرس 2: القيم مصنَّفة النوع

القيم مصنَّفة النوع (Literals) هي عبارات تدل على ثابت تشير صياغته المحرفية إلى نوعه وقيمته، فمثلًا 42 هي قيمة مصنَّفة النوع بينما x ليست كذلك لأنك تحتاج إلى أن تنظر إلى تصريحها (declaration) لتعرف نوعها وتطالع الأسطر السابقة من الشيفرة لتعرف قيمتها. غير أن C++11 أتاحت للمستخدم إضافة قيم مصنَّفة النوع (User-Defined Literals)، وتُستخدم كاختصار لاستدعاءات الدوال.

سنستَعرض في هذا الدرس بعض القيم مصنَّفة النوع في C++‎، بدءًا بالقيمة this، ثم نستعرض بقية القيم في الأقسام التالية.

الكلمة المفتاحية this

تشير الكلمة المفتاحية this داخل دالة تابعة (member function) إلى نسخة من الصنف التي استدعيّت الدالة عليها، ولا يمكن استخدامها -أي this- في دالة تابعة ساكنة (static member function).

struct S {
    int x;
    S & operator = (const S & other) {
        x = other.x;
      
        // تعيد مرجعًا إلى الكائن الذي أسندَت إليه
        return *this;
    }
};

يعتمد نوع ‎this‎ على خاصية التأهيل الخاص بالتابع -سواء التأهيل المتطاير volatile أو الثابت constant- (بالإنجليزية اختصارًا: cv-qualification). فمثلًا، إن كان التابع ‎X::f‎ ثابتًا (‎const‎)، فإنّ نوع ‎this‎ داخل ‎f‎ سيكون مؤشرًا ثابتًا إلى ‎X‎ (أي ‎‎‎const X*‎‎)، لذلك لا يمكن استخدام ‎this‎ لتعديل الحقول غير الساكنة (non-static data members) من داخل دالة const تابعة. وبالمثل، يكتسب ‎this‎ التأهيل المتطاير (volatile qualification) من الدالة التي يظهر فيها. الإصدار ≥ C++11

يمكن أيضًا استخدام ‎this‎ في المُهيِّئ المعقوص (brace-or-equal-initializer) للحقول غير الساكنة.

struct S;
struct T {
    T(const S * s);
    // ...
};
struct S {
    // ...
    T t {
        this
    };
};

‎this‎ عبارة عن قيمة يمينيّة (rvalue)، أي أنّها تعبير لا يمكن أن يكون إلا في الطرف الأيمن من أيّ عملية إسناد (assignment)، لذلك لا يمكن إسناد قيمة لها.

الأعداد الصحيحة قيمةً ونوعًا (Integer literal)

تأخذ صياغة العدد الصحيح أحد الأشكال التالية:

• نوع عشري (decimal-literal): وهو عدد مؤلف من رقم عشري يخالف الصفر (1، 2، 3، 4، 5، 6، 7، 8، 9)، متبوعًا برقم عشريّ واحد أو أكثر (0، 1، 2، 3، 4، 5، 6، 7، 8، 9)، مثلًا:

int d = 42;‎

• نوع ثماني (octal-literal): وهو عدد يبدأ بالرقم صفر (0) متبوعًا برقم ثُمانيّ (octal) واحد أو أكثر (0، 1، 2، 3، 4، 5، 6، 7)، مثلًا:

int o = 052;

• نوع ست عشري (hex-literal): وهو تسلسل الأحرف 0x أو 0X متبوعًا برقم واحد أو أكثر من الأرقام الست عشرية (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F)، مثلًا:

int x = 0x2a; 
int X = 0X2A;‎

• نوع ثنائي (binary-literal): (منذ C ++ 14) هو تسلسل الأحرف 0b أو 0B متبوعًا برقم ثنائي واحد أو أكثر (0، 1)، مثلا:

int b = 0b101010;‎

• الأعداد الصحيحة الملحوقة غير المؤشّرة (unsigned-suffix)، قد تحتوي على أحد أو كلا الأمرين التاليين -قد يظهرا بدون ترتيب محدد في حالة وجودهما معًا:
  • الأعداد الملحوقة غير المُؤشرة (unsigned-suffix): هي أعداد ملحوقة بالحرف u أو U، مثلا:

unsigned int u_1 = 42u;‎

• الأعداد الملحوقة الطويلة (long-suffix): هي أعداد ملحوقة بالحرف l أو L، أو الأعداد الملحوقة الطويلة المزدوجة (long-long-suffix)، وهي أعداد ملحوقة بالحرفين ll أو الحرفين LL (منذ C++11‎)

تأخذ المتغيرات التالية نفس القيمة:

unsigned long long l1 = 18446744073709550592ull; // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL; // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU; // C++14

ملاحظات

الأحرف الموجودة في الأعداد الصحيحة غير حساسة للحالة (case-insensitive): فتمثل الصيغتان 0xDeAdBaBeU و 0XdeadBABEu نفس العدد (الاستثناء الوحيد هو الأعداد الملحوقة الطويلة المزدوجة، والتي يمكن أن تكون إما ll أو LL، ولكن ليس lL أو Ll).

لا توجد صياغة لأعداد سالبة، فمثلًا تطبق تعابير مثل ‎-1 عامل السالب الأحادي (unary minus operator) على القيمة المُمثّلة بالقيمة مصنفَّة النوع (Literal)، والتي قد تتضمن تحويلات ضمنية للنوع (implicit type conversions).

في إصدارات C السابقة للإصدار C99 (ولكن ليس في C++‎)، يُسمح للقيم العشرية غير الملحوقة (unsuffixed decimal) من غير النوع long int أن تكون من النوع unsigned long int (عدد صحيح طويل عديم الإشارة).

تتصرف جميع الثوابت الصحيحة المؤشَّرة (signed integer constants) عند استخدامها في التعبيرات الشرطية -مثل ‎#if أو ‎#elif- كما لو كانت من النوع std::intmax_t، فيما تتصرف الثوابت الصحيحة غير المؤشرة كما لو كانت من النوع std::uintmax_t.

القيم المنطقية

الكلمة المفتاحية true

true هي كلمة مفتاحية تمثّل إحدى القيمتين المنطقيّتين المُمكنَتين للنوع ‎bool‎.

bool ok = true;
if (!f()) {
    ok = false;
    goto end;
}

الكلمة المفتاحية false

false هي كلمة مفتاحية تمثل إحدى القيمتين المنطقيّتين المُمكنتين للنوع ‎bool‎.

bool ok = true;
if (!f()) {
    ok = false;
    goto end;
}

الكلمة المفتاحية nullptr

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

nullptr هي كلمة مفتاحية تمثل مؤشرًا ثابتًا فارغًا (null pointer constant)، ويمكن تحويلها إلى أيّ نوع من المؤشرات (Pointers) أو المؤشرات إلى الأعضاء (pointer-to-member)، وتعيد مؤشرًا فارغًا يشير إلى النوع الناتج.

Widget* p = new Widget();
delete p;
p = nullptr; // تفريغ المؤشر بعد الحذف

لاحظ أنّ ‎nullptr‎ ليست مؤشرًا بحد ذاتها، وإنّما هي نوع أساسي معروف باسم ‎std::nullptr_t‎.

void f(int * p);
template < class T >
    void g(T * p);
void h(std::nullptr_t p);
int main() {
    f(nullptr); // ok
    g(nullptr); // error
    h(nullptr); // ok
}

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

ترجمة -وبتصرّف- للفصل Chapter 2: Literals من كتاب C++ Notes for Professionals

اقرأ أيضا

• الدرس 3: أسبقية العمليات
• الدرس 1: مدخل إلى C++‎

مرحبا بالعالم

يطبع البرنامج التالي العبارة مرحبًا بالعالم! في مجرى الخرج القياسي (standard output stream):

#include <iostream>

int main() {
    std::cout << "مرحبا بالعالم!" << std::endl;
}

يمكنك رؤية التجربة الحية على Coliru.

تحليل البرنامج

لنحلل كل جزء من شيفرة البرنامج بالتفصيل:

#include <iostream>

هو موجّه معالجة مسبقة (preprocessor directive)، ويتضمن محتوى iostream، وهي ترويسة ملف C++‎ القياسي (standard C++ header file).

الكلمة iostream هي ترويسة ملف مكتبة قياسية (standard library header file)، وتحتوي على تعريفات مُجريَا الدخل والخرج القياسيين (standard input and output streams). هذه التعريفات مُتضمنة في فضاء الاسم std، كما هو موضح أدناه.

يوفر مُجريا الدخل/الخرج القياسيين (I/O) طريقة للبرامج يمكنه عبرها جلب مدخلات من مخرجات خاصة بنظام خارجي، والذي يكون طرفية في العادة.

int main() { ... }

تُعرِّف هذه الشيفرة دالة جديدة باسم main تستدعى عند تنفيذ البرنامج. يجب أن تكون هناك دالة main واحدة لكل برنامج C++‎، ويجب أن تعيد دائمًا عددًا من النوع int. يمثل int نوع القيمة التي تعيدها الدالة والتي تمثل رمز الخروج (exit code) الخاص بالدالة main.

البرامج ذات رمز الخروج المساوي للقيمة 0 أو EXIT_SUCCESS تُعد ناجحة من قبل النظام الذي ينفّذ ذلك البرنامج. ترتبط كل رموز الخروج الأخرى بأخطاء تحددها هي.

في حال عدم استخدام التعليمة return، ستعيد الدالة main (وبالتالي البرنامج نفسه) القيمة 0 افتراضيًّا. في هذا المثال لا نحتاج إلى كتابة ;return 0.

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

std::cout << "مرحبا بالعالم!" << std::endl;

تطبع هذه التعليمة السلسلة النصية "مرحبا بالعالم!" في مجرى الخرج القياسي، وتتألف من الأجزاء التالية:

• std: هي فضاء اسم، و :: هو عامل تحليل النطاق (scope resolution operator) الذي يسمح بالبحث عن الكائنات بأسمائها ضمن فضاء الاسم. هناك العديد من فضاءات الاسم. هنا نستخدم :: لإظهار أننا نريد استخدام cout من فضاء الاسم std. لمزيد من المعلومات، ارجع إلى المقال Scope Resolution Operator في توثيق ميكروسوفت.
• std::cout: هو كائن مجرى الخرج القياسي (standard output)، وهو مُعرّف في iostream، ويُطبع أيّ شيء يُمرَّر إليه في مجرى الخرج القياسي (stdout).
• >>: هي، في هذا السياق، عامل الإدراج (stream insertion operator)، ويُسمى كذلك لأنه يدرج كائنًا في كائن المجرى (stream object). تُعرِّف المكتبة القياسية العامل >> لإدراج بعض أنواع البيانات في مجاري الخرج. تدرج التعليمة stream << content المحتوى content في المجرى stream ثم تعيد المجرى نفسه بعد تحديثه. يسمح ذلك بإجراء الإدراجات المتسلسلة، مثلًا، تطبع التعليمة std::cout << "Foo" << " Bar";‎ السلسة النصية "Foo Bar" في سطر الأوامر.
• "مرحبا بالعالم!": هي سلسلة نصية حرفية (character string literal). عامل الإدراج الخاص بالسلاسل النصية مُعرّف في الملف iostream.
• std::endl: هو كائن خاص لمعالجة مجرى I/O، وهو مُعرّف في الملف iostream. إنّ إدراج معالج في مجرى ما يغير حالة ذلك المجرى. يقوم معالج المجرى std::endl بعملين: أولًا، يدرج محرف نهاية السطر (end-of-line character)، ثم ينقل البيانات (flushes) الموجودة في المخزن المؤقت (stream buffer) الخاص بالمجرى لجعل النص يظهر في سطر الأوامر. يضمن هذا أنّ البيانات المُدرجة في المجرى ستظهر بالفعل في وحدة التحكم. (تُخزنّ بيانات المجرى عادة في مخزن مؤقت، ثم تُنقَل على دفعات، إلا إذا أمرت بنقلها فوريًا.)

هناك طريقة بديلة تُجنِّب نقل البيانات من المخزن المؤقت، وهي:

std::cout << "Hello World!\n"; 
// سطرًا جديدًا \n يمثل

• الفاصلة المنقوطة ;: تُخطر الفاصلة المنقوطة (;) المُصرّف (compiler) بأنّ التعليمة البرمجية قد انتهت. تتطلب كل عبارات C++‎ وتعريفات الأصناف استخدام فاصلة منقوطة في النهاية.

التعليقات

التعليقات هي جزء من الشيفرة يتجاهلها مصرف C++‎. تُستخدم التعليقات لتوضيح بعض الجوانب التي قد تكون غامضة بخصوص تصميم أو طريقة عمل البرنامج.

هناك نوعان من التعليقات في C++‎:

التعليقات السطرية (Single-Line Comments)

تجعل الشرطتان المائِلتان // النص الذي يليها وحتى بداية السطر الجديد تعليقًا:

int main() {
    // هذا تعليق سطري
    int a; // هذا تعليق سطري كذلك
    int i; // هذا أيضا تعليق سطري
}

التعليقات الكُتلية (Block Comments)

يُستخدَم المحرفان ‎/*‎ للإعلان عن بداية تعليق كتلي، فيما يُستخدَم المحرفان ‎*/‎ للإعلان عن نهاية التعليق. يُفسَّر النص الموجود بين العبارتين على أنه تعليق، حتى لو كان النص الموجود بينهما شيفرة C++‎ صالحة. يسمى هذا النوع من التعليقات عادة تعليقات "C-style"، لأنّ صياغة هذ النوع من التعليقات موروثة من سلف C++‎، أي اللغة C:

int main()
{
    /*
     *  هذا تعليق كتلي
     */
    int a;
}

يمكنك كتابة ما تشاء في التعليقات الكتلية لكن عندما يجد المصرّف رمز نهاية التعليق‎*/‎، فإنه ينهي التعليق الكتلي:

int main()
{
/* تعليق كتلي يمتد 
* على عدة أسطر 
* وينتهي في السطر التالي
*/ 
  
int a;
}

يمكن أيضًا أن تبدأ التعليقاتُ الكتلية وتنتهي في سطر واحد. مثلا:

void SomeFunction(/* الوسيط الأول */ int a, /* الوسيط الثاني */ int b);

أهمية التعليقات

كما هو الحال مع جميع لغات البرمجة، توفر التعليقات العديد من الفوائد، منها:

• توثيق ضمني للشيفرة البرمجية لتسهيل قراءتها وصيانتها
• شرح الغرض من الشيفرة البرمجية ودوالها
• توفير تفاصيل حول تاريخ الشيفرة أو المنطق وراءها
• وضع حقوق الطبع والنشر/التراخيص، أو ملاحظات حول المشروع، أو شكر خاص، أو التنويه بالمساهمين، وما إلى ذلك مباشرة في الشيفرة المصدرية (source code).

من جهة أخرى، فإنّ للتعليقات جانبًا سلبيًا كذلك:

• يجب تعديلها لتعكس أي تغييرات في الشيفرة
• الإفراط في إدراج التعليقات قد يؤثر سلبًا على مقروئية الشيفرة.

يمكن تقليل الحاجة إلى التعليقات عبر كتابة شيفرة واضحة ومُوثقة ذاتيًا (self-documenting). أحد الأمثلة على ذلك هو استخدام أسماء توضيحية للمُتغيرات والدوال والأنواع. وتوزيع المهام المترابطة منطقيًا في دوال منفصلة.

تعليق الشيفرة واختبارها

أثناء التطوير، يمكن أيضًا استخدام التعليقات لتعطيل أجزاء من الشيفرة بسرعة دون حذفها. غالبًا ما يكون هذا مفيدًا في مرحلة الاختبار أو التنقيح (debugging)، ولكن ينبغي محو تلك التعليقات بعد الانتهاء. يشار إلى هذا غالبًا باسم "تعليق الشيفرة" (commenting out).

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

عملية التصريف القياسية في C++‎‎

تُنتَج برامج C++‎ القابلة للتنفيذ عادة بواسطة المُصرّف (compiler)، وهو برنامج يترجم الشيفرة من لغة برمجة إلى شيفرة تنفيذية تفهمها الآلة وتُنفذ على الحاسوب من قبل المستخدم النهائي. استخدام المصرّف لتصريف الشيفرة يسمى عملية التصريف (compilation process‎).

ورثت C++‎ آلية التصريف من سلفها، أي اللغة C. فيما يلي قائمة توضح الخطوات الرئيسية الأربع للتصريف في C++‎:

1. ينسخ المعالج الأولي (preprocessor) للغة C++‎ محتويات كل ملفات الترويسات (header files) المتضمنة في ملف الشيفرة المصدري، ويولد «شيفرة عملية بدل» (macro code، ويعوّض الثوابت الرمزية (symbolic constants) المعرفّة باستخدام ‎#define‎ بقِيمهما.
2. تُصرَّف الشيفرة المصدرية الموسعة التي أُنتِجت بواسطة المعالج الأولي لـ C++‎ إلى لغة التجميع (assembly language) المناسبة لنظام التشغيل.
3. تُصرَّف الشيفرة المجمّعة التي أُنتِجت بواسطة المصرّف إلى تعليمات مُصرّفة (object code) مناسبة لنظام التشغيل.
4. تُربَط التعليمات المُصرَّفة المُولّدة من قبل المجمّع (assembler) مع ملفات التعليمات المُصرَّفة (object code files) الخاصة بدوال المكتبات المستخدمة لإنتاج الملف القابل للتنفيذ.

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

تدمج العديد من مصرّفات C++‎ أو تفكّك بعض مراحل عملية التصريف لتسهيل العملية، أو لأجل التحليل الإضافي. يستخدم مُبرمجو C++‎ أدوات مختلفة، لكنها جميعًا تتبع المقاربة أعلاه.

الدوال

الدالة هي كتلة من الشيفرة تحتوي سلسلة من العبارات. يمكن للدوال قبول وسائط (arguments) أو قيم، ويمكن أن تعيد قيمة واحدة، أو قد لا تعيد أي قيمة. لاستخدام دالة، يجب استدعاؤها مع تمرير وسائط إليها، ثم تعيد قيمة.

لكل دالة بصمة نوعيّة (type signature)، والتي تمثل أنواع وسائطها، ونوع القيمة المعادة. الدوال مستوحاة من مفهومَي الإجراء (procedure) والدالة في الرياضيات.

ملاحظات:

• دوال C++‎ هي إجراءات (procedures) بالأساس، ولا تتبع بدقة قواعد الدوال الرياضية وفق مفهوم علوم الرياضيات.
• تؤدي الدوال في العادة مهام محددة ويمكن استدعاؤها من أجزاء أخرى من البرنامج. كما يجب التصريح عن الدالة وتعرِيفها قبل استدعائها في البرنامج.
• قد تُخفى تعريفات الدوال الشائعة والمهمة في ملفات أخرى مُضمّنة، فذلك يسهِّل إعادة استخدامها في البرامج. وهذا أحد الاستخدامات الشائعة لملفات الترويسات (header files).

التصريح عن دالة

التصريح عن دالة (Function Declaration) هو عملية الإعلان عن وجود دالة، مع توضيح اسمها وبصمتها النوعيّة للمصرف. ويتبع الصياغة التالية:

// الدالة التالية تقبل عددًا صحيحًا وتعيد عددًا صحيحًا
int add2(int i); 

في المثال أعلاه، تخبر int add2(int i)‎ المصرّف بالمعلومات التالية عن الدالة المُصرَّح عنها:

• نوع القيمة المعادة هو int.
• اسم الدالة هو add2.
• عدد وسائط الدالة هو 1:
  • الوسيط الأول من النوع int.
  • سيُشار إلى الوسيط الأول داخل الدالة بالاسم i.

اسم الوسيط اختياري؛ إذ يمكن التصريح بالدالة كما يلي:

int add2(int); // يمكن حذف اسم الوسيط

وفقًا لقاعدة التعريف الواحد (one-definition rule)، لا يمكن التصريح بدالة ذات بصمة (signature) نوعيّة معينة أو تعريفها أكثر من مرة واحدة في كامل شيفرة C++‎ المرئية للمصرّف. بمعنى آخر، لا يمكن إعادة تعريف دالة ذات بصمة نوعية معيّنة إلا مرة واحدة فقط. وبالتالي، فالشيفرة التالية غير صالحة في C++‎ وسيطلق المصرف خطأ عند تنفيذها:

// int هي دالة من النوع add2 المصرف سيعلم أن
int add2(int i); // (int) -> int

// لا يمكن إعادة تعريف نفس الدالة بنفس البصمة
int add2(int j); // (int) -> int

إذا لم تُعِد الدالة أي قيمة، فإنّ نوع القيمة المعادة سيُكتب void. إذا لم تأخذ الدالة أيّ معاملات، فينبغي أن تكون قائمة المعاملات فارغة.

// الدالة التالية لا تأخذ أي وسائط، ولا تعيد أي قيمة
void do_something(); 

لاحظ أنه ما يزال بمقدور الدالة do_something التأثير في المتغيرات التي يمكنها الوصول إليها.

استدعاء الدالة

يمكن استدعاء الدالة بعد التصريح عنها. على سبيل المثال، يستدعي البرنامج التالي الدالة add2 مع القيمة 2 داخل الدالة main:

#include <iostream>

int add2(int i); // add2 تعريف الدالة

int main() {
  
    // في هذا الموضع add2(2) سيتم تقييم
    std::cout << add2(2) << "\n";
    
    // وستُطبع النتيجة
    return 0;
}

بالنظر إلى الشيفرة السابقة، نجد أنَّه ما تزال الدالة add2 تحتاج إلى توفير طريقة تنفيذ لها بالإضافة إلى تعريفها (جسم الدالة)، رغم أن تنفيذ الدالة لا يظهر مباشرة في الشيفرة، إذ يمكن جلبه من ملف آخر بربط هذا الملف مع الشيفرة التي تستدعي الدالة.

تمثل add2(2)‎ صياغة استدعاء دالة.

تعريف الدالة

تعريف الدالة يشبه التصريح عنها، إلا أنه يحتوي أيضًا على الشيفرة الذي ستُنفّذ عند استدعاء الدالة، هذه الشيفرة تُسمى جسم الدالة (function body). فيما يلي مثال عن تعريف الدالة add2:

// i القيمة التي ستُمرر إلى الدالة سيشار إليها بالاسم 
int add2(int i) 
{
  	// بين القوسين يمثل داخل نطاق أو جسم الدالة

    int j = i + 2; 
    return j; 
}

زيادة تحميل الدوال

يمكنك إنشاء عدة دوال تشترك في نفس الاسم، ولكن مع اختلاف المعاملات، أي تختلف بصمة الدالة فقط، وهذا ما يعرف «بزيادة تحميل دالة» (Function Overloading).

// التنفيذ الأول
int add2(int i) 
{
    int j = i + 2;
    return j;
}

// التنفيذ الثاني
int add2(int i, int j) 
{
    int k = i + j + 2;
    return k; //
}

كلتا الدالتين تحملان الاسم add2، بيْد أنّ الدالة المُنفّذة تعتمد على عدد وأنواع المعاملات المُمررة في الاستدعاء. في معظم الحالات، يمكن لمصرّف C++‎ أن يحدد الدالة المراد استدعاؤها. لكن في بعض الحالات يجب ذكر النوع بوضوح. فسيتم تقييم الشيفرة المحتواة في التعريف الأول عند استدعاء الدالة نع معامل واحد بالشكل add2(1)‎. وفي حال استدعاء الدالة مع معاملين بالشكل add2(1, 3)‎، فسيتم تقييم الشيفرة المتضمنة في التعريف الثاني بدلًا من التعريف الأول.

المعاملات الافتراضية

يمكن تحديد القيم الافتراضية لمعاملات الدالة (Default Parameters) في تعريفات الدوال فقط.

// 7 هي b القيمة الافتراضية للمعامل
int multiply(int a, int b = 7);

// جسم الدالة
int multiply(int a, int b) {
    return a * b; 
}

في هذا المثال، يمكن استدعاء multiply()‎ مع معامل واحد أو مُعاملين. في حال تمرير معامل واحدة فقط، فستكون القيمة الافتراضية للمعامل b هي 7 وسيتم ضرب القيمة الممررة تلك بالمعامل الافتراضي 7 آنذاك. يجب وضع المعاملات الافتراضية في الأخير على النحو التالي:

// تعريف صحيح
int multiply(int a = 10, int b = 20); 

// مُقدّمة int a تعريف غير صحيح لأن
int multiply(int a = 10, int b); 

استدعاءات خاصة للدوال - العوامل

توجد استدعاءات خاصة في C++‎ للدوال، وهي ذات صياغة مختلفة عن الصياغة التقليدية name_of_function(value1, value2, value3)‎. المثال الأكثر شيوعا هي العوامل (operators). وهي تسلسلات أحرف خاصة تحوَّل إلى استدعاءات دوال من طرف المصرّف، من أمثلة ذلك، ! و + و - و * و % و ‎<<‎ وغيرها. عادةً ما ترتبط هذه المحارف الخاصة باستخدامات غير برمجية، أو تُستخدم للتبسيط (على سبيل المثال، المحرف + يمثل عادةً مفهوم الإضافة). تعالج C++‎ هذه التسلسلات؛ وتحوّل كل عامل إلى استدعاء الدالة المقابلة. على سبيل المثال، التعبير‎ التالي:

3+3

يكافئ استدعاء الدالة التالية:

operator+(3, 3)

تبدأ جميع أسماء دوال العوامل بـ operator. في لغة C، لا يمكن تعيين معان جديدة لأسماء دوال العوامل عبر كتابة تعريفات إضافية ذات بصمات نوعية مختلفة، في C++‎، هذا جائز. يشار إلى ربط تعريفات إضافية بنفس اسم الدالة باسم التحميل الزائد للعامل (operator overloading) في C++‎، وهو اصطلاح شائع نسبيًا، ولكنه غير عام في C++‎.

التصريح عن الدوال وقواعد مرئيتها

في C++‎، يجب التصريح عن الشيفرة أو تعريفها قبل استخدامها. على سبيل المثال، ينتج عن الشيفرة التالية خطأ في وقت التصريف:

int main() {
    foo(2); // (*)
}
void foo(int x) 
{}

سيطلق خطأ، لأن الدالة foo استُدعِيت في السطر (*) قبل أن تُعرّف، إذ لا ترى الدالة main هذا التعريف المتأخر للدالة foo بعد استدعائها ضمنها.

هناك طريقتان لحل هذه المشكلة: إما التصريح عن foo()‎ أو تعريفها قبل استخدامها في main()‎. هذا مثال على ذلك:

// ووضع جسمها أولا foo التصريح عن الدالة
void foo(int x) {} 
int main() {
  
    // الآن foo يمكن استدعاء الدالة
    foo(2); 
}

من الممكن أيضًا التصريح المسبق (forward-declaration) عن الدالة عن طريق وضع تصريح عن قالبها (prototype declaration) قبل موضع استدعائها والذي يحدد نوع القيمة المعادة واسم الدالة وعدد وسائطها وأنواعها، ثم تعريف جسمها لاحقًا:

// foo تصريح عن قالب لدالة باسم
void foo(int); 

int main() {
    foo(2);  // (*)
}

// ينبغي أن تطابق تصريح القالب أعلاه
void foo(int x) 
{
    // هنا foo تعريف جسم
}

أصبحت الدالة foo مرئية، لذا يمكن استدعاؤها الآن ضمن الدالة main في السطر (*) رغم أنها لم تُعرّف بعد.

يجب أن يحدد تصريح النموذج نوع القيمة المعادة (void)، واسم الدالة (foo)، وأنواع المتغيرات في قائمة الوسائط (int)، لكنّ أسماء الوسائط غير ضرورية.

يمكن وضع تصريحات قوالب الدوال في ترويسة الملف:

// foo.h الملف

// تصريح عن قالب دالة
void foo(int); 

ثم تقديم التعريف الكامل في موضع آخر:

// foo.cpp --> foo.o

// foo تضمين الملف الذي يحوي قالب الدالة 
#include "foo.h" 
  
// foo تعريف جسم الدالة
void foo(int x) { } 

ثم، بمجرد تصريف الشيفرة، يمكن ربط كائن الملف (object file) المقابل foo.o بالكائن المصرّف حيث يتم استخدامه في مرحلة الربط، main.o:

// main.cpp --> main.o

// foo تصريح عن قالب الدالة
#include "foo.h" 
int main() { foo(2); } // (*)

استدعاء الدالة foo ممكن هنا، لأنه سبق التصريح عنها، وتعريف قالب ومتن الدالة foo مربوط عبر كائنات الملفات (object files). 

يحدث الخطأ "رمز خارجي غير محلول" (unresolved external symbol) إذا صادف المصرّف تصريحَ قالب واستدعاء لدالة، دون وجود لجسمها (body). قد يكون حل هذه الأخطاء معقدًا، لأنّ المصرّف لن يبلِّغ عن الخطأ حتى مرحلة الربط النهائية، ولن يعرف السطر الذي يجب الانتقال إليه في الشيفرة لإظهار الخطأ.

المعالج الأولي

المعالج الأولي (Preprocessor) هو جزء مهم من المصرّف إذ يقوم بتعديل الشيفرة المصدرية، وحذف بعض البتات، أو تغييرها، وإضافة أشياء أخرى.

في الملفات المصدرية، يمكننا تضمين مُوجِّهات (directives) للمعالج الأولي. تخبر تلك الموجِّهات المعالج الأولي بتنفيذ إجراءات محددة. يبدأ الموجّه بالرمز # في سطر جديد مثل:

#define ZERO 0

من أشهر مُوجهات المعالج الأولي، الموجهات التالية:

#include <something>

يأخذ هذا الموجه something ويُدرجه في ملفك حيث يظهر الموجه. مثلا، يبدأ برنامج "مرحبا بالعالم!" بالسطر التالي:

#include <iostream>

يضيف هذا السطر الدوال والكائنات التي تتيح لك استخدام المدخلات والمخرجات القياسية. لا تحتوي اللغة C (والتي تستخدم أيضًا المُعالج الأولي) نفس القدر من ترويسات الملفات كخَلَفها C++‎، كما أنه يمكنك في C++‎ استخدام جميع ترويسات C.

المُوجِّه الثاني في الأهمية هو على الأرجح الموجّه التالي:

#define something something_else

يخبر هذا المُوجِّه المعالج الأولي بأنه يجب أن يبدِّل something مكان كل ظهور لـ something_else في الملف الحالي. يمكن أن يجعل هذا الموجّه بعض الأشياء تتصرف مثل دوال، لكنه مفهوم متقدم أشرنا إليه قبل قليل على أنه «شيفرة عملية بدل» (macro code)، ولن نتطرق إليه الآن.

something_else ليس ضروريًا، ولكن في حال عدم إضافة something، سيُحذَف كل ظهور لـ something.

هذا مفيد جدا، إذ يمكن استخدامه مع المُوجِّهات ‎#if و ‎#else و ‎#ifdef. وفق الصياغة التالية:

#if something == true
    // شيفرة
#else
    // شيفرة أخرى
#endif

#ifdef thing_that_you_want_to_know_if_is_defined
    // شيفرة
#endif

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

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

ترجمة -وبتصرّف- للفصل Chapter 1: Getting started with C++‎ من الكتاب C++ Notes for Professionals

اقرأ أيضًا

• الدرس 2: القيم مصنَّفة النوع