getline في C++: قراءة سطر كامل وإصلاح تخطي الإدخال وقراءة الملفات

قراءة سطر كامل

يقرأ cin >> text كلمة واحدة: يتوقف عند أول مسافة. لقراءة كل ما كتبه المستخدم حتى مفتاح Enter، بما في ذلك المسافات، استخدم std::getline من الترويسة <string>:

#include <iostream>
#include <string>

int main() {
    std::string name;
    std::cout << "Full name: ";
    std::getline(std::cin, name);
    std::cout << "Hello, " << name << "!\n";
}

كتابة Ada Lovelace تطبع Hello, Ada Lovelace!. أما مع std::cin >> name فسيُطبع Hello, Ada! وتبقى Lovelace منتظرة في الإدخال.

التوقيع هو:

std::istream& std::getline(std::istream& input, std::string& text);
std::istream& std::getline(std::istream& input, std::string& text, char delim);

• input أي تدفق إدخال: std::cin، أو ملف مفتوح باستخدام std::ifstream، أو std::istringstream مبني من نص.
• يُستبدل محتوى text (ولا يُضاف إليه) بالمحارف المقروءة.
• delim هو المحرف الذي ينهي القراءة، وقيمته الافتراضية '\n'. يُزال المحدد من التدفق ولا يُخزَّن في text.
• القيمة المُرجعة هي التدفق نفسه، وهذا ما يتيح لك اختباره داخل شرط.

لأن getline تعمل بالطريقة نفسها على كل تدفق إدخال، تقرأ الأمثلة القابلة للتشغيل في هذه الصفحة من std::istringstream يحمل نصًا ثابتًا. هذا يجعل المخرجات متوقعة دون أن تكتب شيئًا. وللقراءة من لوحة المفاتيح بدلًا من ذلك، استبدل متغير التدفق بـstd::cin.

#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::istringstream input("Ada Lovelace\nAlan Turing\n");
    std::string first, second;

    std::getline(input, first);
    std::getline(input, second);

    std::cout << "[" << first << "]\n";
    std::cout << "[" << second << "]\n";
}

المخرجات:

[Ada Lovelace]
[Alan Turing]

تُظهر الأقواس المربعة أن السطر الجديد ليس جزءًا من أي من النصين.

getline بعد cin >> تُرجع نصًا فارغًا

هذه أشهر مشكلات getline. تقرأ رقمًا باستخدام >>، ثم سطرًا باستخدام getline، فتبدو getline كأنها تُتخطى:

#include <iostream>
#include <sstream>
#include <string>

int main() {
    // ما يكتبه المستخدم: 30، ثم Enter، ثم Paris، ثم Enter
    std::istringstream input("30\nParis\n");

    int age;
    std::string city;

    input >> age;
    std::getline(input, city);

    std::cout << "age: " << age << "\n";
    std::cout << "city: [" << city << "]\n";
}

المخرجات:

age: 30
city: []

يقرأ input >> age المحرفين 30 ويتوقف عند أول محرف لا يمكن أن يكون جزءًا من رقم، وهو السطر الجديد. يبقى ذلك السطر الجديد في التدفق. ثم تقرأ getline حتى السطر الجديد التالي، فتجده فورًا وتُرجع نصًا فارغًا. ومع std::cin تكون النتيجة أن البرنامج لا يتوقف أبدًا لانتظار الإجابة الثانية.

هناك حلّان معياريان، وكلاهما يوضع بين >> وgetline.

الحل 1: التخلص من باقي السطر باستخدام ignore.

#include <iostream>
#include <limits>
#include <sstream>
#include <string>

int main() {
    std::istringstream input("30\nParis\n");

    int age;
    std::string city;

    input >> age;
    input.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    std::getline(input, city);

    std::cout << "age: " << age << "\n";
    std::cout << "city: [" << city << "]\n";
}

المخرجات:

age: 30
city: [Paris]

يتخلص ignore(n, '\n') من المحارف حتى يزيل سطرًا جديدًا أو n محرفًا، أيهما يأتي أولًا. وتمرير أكبر قيمة ممكنة من std::streamsize يعني "حتى السطر الجديد، مهما كان بعيدًا". ويزيل أيضًا أي شيء كتبه المستخدم بعد الرقم على السطر نفسه، مثل المسافات الزائدة في النهاية. ومع لوحة المفاتيح يكون السطر std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');، ويحتاج إلى #include <limits>.

أما std::cin.ignore() المجردة فتتخلص من محرف واحد بالضبط. تنجح عندما يلي السطر الجديد الرقم مباشرة، وتفشل بمجرد وجود مسافة قبله.

الحل 2: تخطي الفراغات في البداية باستخدام std::ws.

#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::istringstream input("30\n\n   Paris\n");

    int age;
    std::string city;

    input >> age;
    std::getline(input >> std::ws, city);

    std::cout << "age: " << age << "\n";
    std::cout << "city: [" << city << "]\n";
}

المخرجات:

age: 30
city: [Paris]

std::ws مُعدِّل (manipulator) يستهلك كل الفراغات (المسافات وعلامات الجدولة والأسطر الجديدة) في الموضع الحالي. يُرجع input >> std::ws التدفق، لذا يمكن تمريره مباشرة إلى getline. ويتخطى أيضًا الأسطر الفارغة والمسافات في البداية، وهذا مريح مع الأسماء والمدن، لكنه خطأ عندما تكون المسافات في البداية أو السطر الفارغ إدخالًا له معنى. في هذه الحالة استخدم ignore.

القراءة حتى نهاية الإدخال

تُرجع getline التدفق، والتدفق يتحول إلى false بمجرد أن تفشل قراءة. وعندما لا تبقى أسطر، تفشل getline، لذا فإن حلقة while حولها تقرأ كل سطر وتتوقف عند النهاية:

#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::istringstream input("apples 3\nbread 1\n\nmilk 2\n");
    std::string line;
    int count = 0;

    while (std::getline(input, line)) {
        ++count;
        std::cout << count << ": [" << line << "]\n";
    }

    std::cout << "read " << count << " lines\n";
}

المخرجات:

1: [apples 3]
2: [bread 1]
3: []
4: [milk 2]
read 4 lines

تفصيلان من هذه المخرجات:

• السطر الفارغ ما زال قراءة ناجحة. يعطي نصًا فارغًا وتستمر الحلقة. وحده الوصول إلى نهاية الإدخال يوقفها.
• السطر الأخير لا يحتاج إلى سطر جديد في نهايته. لو انتهى النص بـmilk 2 دون \n، لأرجعته getline مع ذلك، ولفشل الاستدعاء التالي.

ومع std::cin تقرأ الحلقة نفسها حتى ينتهي الإدخال. ويحدث ذلك عندما يُمرَّر الإدخال من ملف (./program < data.txt)، أو عندما يضغط المستخدم Ctrl+D على macOS وLinux، أو Ctrl+Z ثم Enter على Windows.

تجنّب النمط while (!input.eof()) { std::getline(input, line); ... }. لا تصبح eof() صحيحة إلا بعد أن تصل قراءة ما إلى النهاية فعلًا، فيُنفَّذ جسم الحلقة مرة إضافية بقراءة فاشلة وبقيمة line قديمة. ضع استدعاء getline في الشرط بدلًا من ذلك.

قراءة ملف سطرًا سطرًا

تستخدم الملفات الحلقة نفسها. افتح الملف باستخدام std::ifstream من <fstream>، وتحقق من أنه فُتح، ثم اقرأ:

#include <fstream>
#include <iostream>
#include <string>

int main() {
    // أنشئ ملفًا صغيرًا ليجد المثال شيئًا يقرؤه.
    {
        std::ofstream out("scores.txt");
        out << "Ada 92\n" << "Grace 88\n" << "Alan 95\n";
    }   // يُغلَق out هنا

    std::ifstream file("scores.txt");
    if (!file) {
        std::cerr << "Could not open scores.txt\n";
        return 1;
    }

    std::string line;
    int lineNumber = 0;
    while (std::getline(file, line)) {
        ++lineNumber;
        std::cout << lineNumber << ". " << line << "\n";
    }
}

المخرجات:

1. Ada 92
2. Grace 88
3. Alan 95

يلتقط if (!file) الملف المفقود أو المسار الخطأ قبل الحلقة. وبدونه تقرأ الحلقة ببساطة صفر أسطر، فيبدو الأمر كملف فارغ لا كخطأ. ويُغلق الملف تلقائيًا عندما يخرج file من النطاق في نهاية main.

الملفات المحفوظة على Windows تنهي كل سطر بـ\r\n. وعندما يُقرأ مثل هذا الملف على Linux أو macOS، تزيل getline المحرف \n لكنها تُبقي \r، فينتهي كل سطر بمحرف إرجاع غير مرئي يُفسد مقارنات مثل line == "done". أزِله بعد القراءة:

if (!line.empty() && line.back() == '\r') {
    line.pop_back();
}

استخدام محدد مخصص

يغيّر الوسيط الثالث المحرف الذي ينهي كل قراءة. من الاستخدامات الشائعة تقسيم سطر واحد عند الفواصل. اقرأ السطر أولًا، ثم قسّمه عبر std::istringstream:

#include <iostream>
#include <sstream>
#include <string>
#include <vector>

int main() {
    std::string record = "Ada Lovelace,36,London";

    std::istringstream fields(record);
    std::vector<std::string> parts;
    std::string field;

    while (std::getline(fields, field, ',')) {
        parts.push_back(field);
    }

    std::cout << "fields: " << parts.size() << "\n";
    for (const std::string& p : parts) {
        std::cout << "[" << p << "]\n";
    }
}

المخرجات:

fields: 3
[Ada Lovelace]
[36]
[London]

تُزال الفاصلة من التدفق ولا تُخزَّن، تمامًا كما يحدث مع السطر الجديد في الصيغة الافتراضية. لاحظ أن السطر الجديد مع المحدد المخصص يصبح محرفًا عاديًا. فإذا استدعيت std::getline(file, field, ',') مباشرة على ملف متعدد الأسطر، يعود الحقل الأخير من سطر والحقل الأول من السطر التالي ملتصقين معًا، كما في "London\nGrace Hopper". قراءة سطر واحد في كل مرة وتقسيم كل سطر على حدة تتجنب ذلك. تشرح صفحة تدفقات النصوص std::istringstream بتفصيل أكبر، بما في ذلك تحويل حقول مثل "36" إلى أرقام.

std::getline مقابل cin.getline

هناك أيضًا دالة عضو باسم مشابه:

char buffer[20];
std::cin.getline(buffer, 20);        // دالة عضو، مصفوفة char ثابتة الحجم

std::string text;
std::getline(std::cin, text);        // دالة حرة، std::string

تكتب cin.getline داخل مصفوفة char، وتخزّن size - 1 محرفًا على الأكثر إضافة إلى المحرف الختامي '\0'. والسطر الأطول يضع التدفق في حالة فشل، وتُتخطى كل قراءة لاحقة حتى تستدعي std::cin.clear(). أما std::getline مع std::string فليس فيها حد للطول تديره. استخدمها إلا إذا كنت تعمل مع واجهة برمجية تتطلب مصفوفة char.

أخطاء شائعة

• مزج >> وgetline دون التخلص من السطر الجديد. أضف ignore(...) أو استخدم std::ws بينهما. تعرض صفحة الإدخال والإخراج المشكلة نفسها مع std::cin، وكيف تتعافى عندما تفشل قراءة رقمية.
• استدعاء getline(std::cin, number) مع متغير int. لا تقرأ getline إلا إلى std::string. اقرأ السطر، ثم حوّله باستخدام std::stoi أو std::istringstream.
• بناء الحلقة على eof(). اختبر استدعاء getline نفسه: while (std::getline(input, line)).
• نسيان #include <string>. يُصرَّح عن std::getline الخاصة بالنصوص في <string>. بعض المترجمات تمررها عبر <iostream>، ثم يفشل الكود على مترجم آخر.
• عدم التحقق من أن الملف فُتح. المسار الخطأ يجعل std::ifstream يفشل بصمت، وتُنفَّذ حلقة القراءة صفر مرات.