string ও string_view — লেখা নিয়ে কাজ

১ · মালিক আর দর্শক — এই পর্বের মূল ধারণা

প্রায় সব প্রোগ্রামই লেখা নিয়ে কাজ করে: নাম, ঠিকানা, ফোন নম্বর, ইমেইল, ফাইলের একেকটি লাইন, ওয়েবসাইটের URL. পর্ব ০৭-এ আপনি std::cin আর std::getline দিয়ে লেখা পড়েছেন, আর পর্ব ১০-এ দেখেছেন বড় লেখা ফাংশনে পাঠাতে const std::string&. এবার প্রশ্ন হলো, লেখা মেমরিতে আসলে কীভাবে থাকে, আর কে তার দেখাশোনা করে?

C++-এ লেখা রাখার দুটি প্রধান টাইপ আছে, আর দুটির দায়িত্ব একেবারে আলাদা। std::string হলো লেখার মালিক। আর std::string_view হলো শুধু একজন দর্শক। এই একটি পার্থক্য বুঝলে পর্বের বাকি সবকিছু সহজ হয়ে যায়।

২ · C string থেকে std::string — কেন বদল দরকার হলো

C-তে আলাদা কোনো string টাইপ নেই। লেখা মানে char-এর একটি array, যার শেষে একটি বিশেষ অক্ষর '\0' বসানো থাকে। একে বলে C string, আর শেষের ওই চিহ্নটি হলো null terminator (NUL). "Dhaka" লিখলে মেমরিতে আসলে ৬টি byte থাকে: D h a k a \0. strlen শুরু থেকে গুনতে গুনতে '\0' পেলে থামে।

এই নকশা সরল, কিন্তু এর তিনটি দায়িত্ব পুরোপুরি প্রোগ্রামারের ঘাড়ে:

• আকার আগে থেকে ঠিক করা। char name[10]; লিখলে সারাজীবন ১০ byte, যার একটি NUL-এর জন্য রাখতে হয়। ব্যবহারকারী ২০ অক্ষরের নাম দিলে কী হবে, আপনাকেই ভাবতে হবে।
• NUL নিজের হাতে বসানো। কোনো ফাংশন NUL বসাতে ভুলে গেলে strlen বা printf array পেরিয়ে পাশের মেমরি পড়তে থাকে।
• কপি নিরাপদে করা। strcpy(name, input) কোনো আকার পরীক্ষা করে না। input বড় হলে সে name-এর বাইরে লিখে ফেলে।

শেষেরটিকে বলে buffer overflow, আর এটি কম্পিউটার নিরাপত্তার ইতিহাসে সবচেয়ে বেশি ব্যবহৃত দুর্বলতাগুলোর একটি। ১৯৮৮ সালের বিখ্যাত Morris worm ইন্টারনেটের হাজারো কম্পিউটারে ঢুকেছিল আংশিকভাবে একটি C প্রোগ্রামের gets ফাংশনের এমন ভুলের সুযোগ নিয়ে। gets এতই বিপজ্জনক যে C11 আর C++14 থেকে এটি standard থেকে পুরোপুরি বাদ দেওয়া হয়েছে।

// পুরোনো পথ — C++-এ এভাবে লিখবেন না
char city[8];
std::strcpy(city, "Chattogram");    // ১১ byte লিখল ৮ byte-এর জায়গায়: buffer overflow

// আধুনিক পথ
std::string town = "Chattogram";    // যত লম্বা হোক, নিজেই জায়গা নেয়
town += " Port";                    // বাড়াতে কোনো হিসাব লাগে না
std::string copy = town;            // সম্পূর্ণ আলাদা কপি, নিরাপদ

শেষ সারির কৌশলটির নাম RAII — মালিক object শেষ হলে তার রিসোর্সও ফেরত যায়। পর্ব ১৭-এ এটি বিস্তারিত দেখবেন। আপাতত জেনে রাখুন, std::string এই নিয়মের সবচেয়ে পরিচিত উদাহরণ।

৩ · প্রতিদিনের কাজ — বানানো, জোড়া, মাপা, তুলনা

std::string পেতে লাগে header <string>. বানানোর কয়েকটি পরিচিত উপায়:

std::string a;                  // খালি লেখা, size() == 0
std::string b = "Rajshahi";     // string literal থেকে
std::string c(5, '*');          // "*****" — একই অক্ষর ৫ বার
std::string d = b + ", BD";     // "Rajshahi, BD"
d += '!';                       // শেষে একটি অক্ষর যোগ

এখানে "Rajshahi" নিজে কোনো std::string নয়। কোডে উদ্ধৃতিচিহ্নের ভেতরে লেখা টেক্সটকে বলে string literal, আর এর টাইপ const char-এর array — C-এর সেই পুরোনো রূপ। std::string তা থেকে একটি নিজস্ব কপি বানিয়ে নেয়। এই কারণে একটি পরিচিত ফাঁদ আছে:

auto s1 = "Dhaka" + "-1205";              // compile error: দুটি ঠিকানা যোগ করা যায় না
auto s2 = std::string("Dhaka") + "-1205"; // ঠিক: বাম পাশে একটি std::string আছে
using namespace std::literals;
auto s3 = "Dhaka"s + "-1205";             // ঠিক: s প্রত্যয় মানে std::string

+-এর অন্তত এক পাশে আসল std::string থাকতে হয়। আর auto x = "Dhaka"; লিখলে x-এর টাইপ হয় const char*, std::string নয় — AI-এর লেখা কোডে এই ভুলটি প্রায়ই দেখা যায়।

মাপা আর একটি অক্ষর পড়া

s.size() (একই কাজ s.length()) বলে লেখায় কয়টি char আছে, আর s.empty() বলে লেখাটি খালি কি না। একটি অক্ষর পড়ার দুটি উপায়, পার্থক্যটা গুরুত্বপূর্ণ:

ইনপুট বা বাইরের ডেটা থেকে আসা অবস্থান হলে at() নিরাপদ। নিজে লুপ লিখে নিশ্চিত থাকলে []. আর পুরো লেখার প্রতিটি অক্ষর দেখতে সবচেয়ে সহজ পথ পর্ব ০৮-এর range-for: for (char ch : s).

তুলনা — অভিধানের ক্রমে, তবে সংখ্যা দিয়ে

== আর != দুটি লেখার প্রতিটি অক্ষর মেলায়। <, > কাজ করে lexicographic order-এ: বাম থেকে প্রথম যে জায়গায় দুটি লেখা আলাদা, সেখানকার দুটি char-এর সংখ্যা-মান তুলনা হয়। তাই "Dhaka" < "Dinajpur" সত্য ('h' আগে আসে 'i'-এর)। কিন্তু সাবধান: ASCII টেবিলে সব বড় হাতের অক্ষর ছোট হাতের অক্ষরের আগে, তাই "Zebra" < "apple"-ও সত্য। নাম সাজানোর প্রোগ্রামে এটি অবাক করা ফল দেয়।

a.compare(b) এক ডাকেই তিনটি উত্তর দেয়: ঋণাত্মক (a আগে), শূন্য (সমান), ধনাত্মক (a পরে)। C++20-এ এর আধুনিক রূপ <=> অপারেটর, যা পর্ব ০৬-এ দেখেছেন। আর প্রায়ই যে প্রশ্নগুলো করতে হয়, তার জন্য সরাসরি ফাংশন আছে:

std::string url = "https://abcltech.com/cpp-programming/";
url.starts_with("https://");   // true  — C++20 থেকে
url.ends_with("/");            // true  — C++20 থেকে
url.contains("cpp");           // true  — C++23 থেকে

এর আগে একই কাজ করতে হতো url.find("cpp") != std::string::npos বা url.rfind("https://", 0) == 0-এর মতো কঠিন লেখায়। পুরোনো compiler-এ কাজ করতে হলে এগুলো চিনে রাখা ভালো, কিন্তু নতুন কোডে সরাসরি নামগুলোই পরিষ্কার।

৪ · খোঁজা আর কাটা — find, substr, replace

লেখা নিয়ে বাস্তবের বেশিরভাগ কাজ দুই ধাপের: আগে কিছু একটা খুঁজুন, তারপর সেই জায়গায় কাটুন বা বদলান। s.find(x) বাম থেকে খুঁজে প্রথম মিলের অবস্থান (০ থেকে গোনা) দেয়, আর s.rfind(x) খোঁজে ডান দিক থেকে। না পেলে দুটোই ফেরত দেয় একটি বিশেষ মান: std::string::npos. তারপর s.substr(pos, len) অবস্থান pos থেকে lenটি অক্ষরের একটি নতুন substring কপি করে দেয়; len না দিলে শেষ পর্যন্ত।

একটি ইমেইল ঠিকানা থেকে ব্যবহারকারীর নাম আর domain আলাদা করা যাক। প্রতিটি ধাপে আগে নিজে অনুমান করুন, তারপর “পরে” চাপুন:

1std::string email = "rafi.ahmed@abcltech.com";2auto at = email.find('@');3std::string user = email.substr(0, at);4std::string domain = email.substr(at + 1);5auto dot = domain.rfind('.');6auto hash = email.find('#');

বদলানো, ঢোকানো, মোছা

তিনটি ফাংশনই আসল string-কে সরাসরি বদলায়, আর প্রথম দুটি আর্গুমেন্ট একই অর্থ বহন করে — কোন অবস্থান থেকে, কয়টি অক্ষর:

std::string s = "Bangladesh Bank";
s.replace(11, 4, "Railway");   // অবস্থান 11 থেকে 4টি অক্ষর বদল: "Bangladesh Railway"
s.insert(0, "The ");           // শুরুতে ঢোকানো: "The Bangladesh Railway"
s.erase(0, 4);                 // প্রথম 4টি অক্ষর মোছা: "Bangladesh Railway"

অবস্থান যদি size()-এর চেয়ে বড় হয়, এই ফাংশনগুলো আর substr সবাই std::out_of_range ছোড়ে। অর্থাৎ find-এর ফল npos কিনা না দেখে সরাসরি substr-এ দিলে প্রোগ্রাম থেমে যেতে পারে। এবার সব একসাথে — ইমেইল ভাগ করা, ফোন নম্বর যাচাই আর একটি রসিদের লাইন বানানো:

#include <print>
#include <string>
#include <string_view>

bool validPhone(std::string_view p) {          // 11 digit, shuru "01" diye
    if (p.size() != 11 || !p.starts_with("01")) return false;
    for (char c : p) if (c < '0' || c > '9') return false;
    return true;
}
int main() {
    std::string email = "rafi.ahmed@abcltech.com";
    auto at = email.find('@');
    if (at != std::string::npos)
        std::println("user = {}, domain = {}", email.substr(0, at), email.substr(at + 1));
    for (std::string_view p : {"01712345678", "0171234567", "0171234567x"})
        std::println("{:<12} -> {}", p, validPhone(p) ? "valid" : "invalid");
    std::string receipt = "Tea x3";
    receipt += " = " + std::to_string(3 * 15) + " Tk";
    std::println("{} ({} chars)", receipt, receipt.size());
}

৫ · লেখা আর সংখ্যা — রূপান্তর ও লাইন ভাগ করা

“21” লেখা আর 21 সংখ্যা মেমরিতে একেবারে আলাদা জিনিস। প্রথমটি দুটি অক্ষর ('2' আর '1', ASCII মান 50 আর 49), দ্বিতীয়টি একটি int. ফাইল, ফর্ম বা নেটওয়ার্ক থেকে সবকিছু আসে লেখা হিসেবে, তাই রূপান্তর প্রতিদিনের কাজ।

std::stoi ভুল লেখা পেলে একটি exception ছোড়ে — অর্থাৎ স্বাভাবিক পথ থামিয়ে ভুলের খবর পাঠায়। কেউ try { … } catch (…) { … } দিয়ে ধরলে প্রোগ্রাম সামলে নিতে পারে; কেউ না ধরলে প্রোগ্রাম সেখানেই বন্ধ। ব্যবহারকারীর ইনপুট প্রায় কখনো নিখুঁত নয়, তাই stoi ব্যবহার করলে try/catch দিন। Exception নিয়ে পুরো আলোচনা পর্ব ৩৭-এ।

std::from_chars এসেছে উচ্চ গতির প্রয়োজনে — বিশাল JSON বা CSV ফাইল পড়তে। এটি কোনো মেমরি চায় না, exception ছোড়ে না, আর কম্পিউটারের ভাষা-সেটিংস (locale) দেখে না, ফলে সব মেশিনে একই ফল দেয়। দামটা হলো, ফল নিজে যাচাই করতে হয়।

একটি CSV লাইন ভাগ করা

CSV (comma-separated values) ফাইলে প্রতিটি লাইন একটি রেকর্ড, ঘরগুলো কমা দিয়ে আলাদা: Rafi,21,Dhaka. ভাগ করার দুটি প্রচলিত উপায়। প্রথমটি, std::istringstream দিয়ে লেখাটিকে একটি stream বানানো, তারপর পর্ব ০৭-এর std::getline-কে থামার অক্ষর ',' দেওয়া। দ্বিতীয়টি, অংশ ৪-এর মতো find(',') লুপ চালিয়ে প্রতিবার substr কাটা। প্রথমটি ছোট আর পরিষ্কার; দ্বিতীয়টি দ্রুত আর string_view-এর সাথে কপি ছাড়াই করা যায়।

#include <charconv>
#include <print>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

int main() {
    std::istringstream in("Rafi,21,Dhaka");
    std::vector<std::string> parts;
    for (std::string field; std::getline(in, field, ','); ) parts.push_back(field);
    std::println("{} fields: [{}] [{}] [{}]", parts.size(), parts[0], parts[1], parts[2]);

    int age = 0;
    auto r = std::from_chars(parts[1].data(), parts[1].data() + parts[1].size(), age);
    std::println("age next year = {}, ok = {}", age + 1, r.ec == std::errc{});

    try { int bad = std::stoi("twenty"); std::println("{}", bad); }
    catch (const std::invalid_argument&) { std::println("stoi failed: not a number"); }

    std::println("UTF-8 bytes in the Bangla word: {}", std::string("বাংলা").size());
}

৬ · ভেতরের কথা — capacity, reallocation আর SSO

std::string কীভাবে “নিজেই বড় হয়”? ভেতরে সে তিনটি তথ্য রাখে: অক্ষরগুলোর মেমরির ঠিকানা, এখন কয়টি অক্ষর আছে (size()), আর নতুন মেমরি না চেয়ে মোট কয়টি রাখা যায় — capacity (capacity()). লম্বা লেখা থাকে heap-এ, অর্থাৎ প্রোগ্রাম চলার সময় চেয়ে নেওয়া মেমরিতে।

যতক্ষণ size() ≤ capacity(), += শুধু খালি জায়গায় অক্ষর বসায় — খুব সস্তা। জায়গা ফুরালে ঘটে reallocation: নতুন, সাধারণত প্রায় দ্বিগুণ মাপের একটি খণ্ড নেওয়া, পুরোনো অক্ষর সেখানে কপি করা, পুরোনো খণ্ড ফেরত দেওয়া। আর ছোট লেখার জন্য প্রায় সব লাইব্রেরি একটি বাড়তি কৌশল করে — Small String Optimization (SSO): লেখা ছোট হলে heap-এ না গিয়ে std::string object-এর নিজের ভেতরেই রেখে দেওয়া। ধাপে ধাপে দেখুন (সংখ্যাগুলো GCC-র লাইব্রেরি libstdc++-এর, 64-bit; অন্য লাইব্রেরিতে আলাদা হবে):

1std::string s;2s = "Dhaka";3s += "-Chattogram";4s += " Highway";5s += " N1 route";

৭ · std::string_view — শুধু দেখার জানালা

পর্ব ১০-এ শিখেছেন, শুধু-পড়ার লেখা পাঠাতে const std::string&. কিন্তু এর একটি লুকানো খরচ আছে। ফাংশনটিকে যদি "Rahim"-এর মতো string literal দেন, compiler আগে একটি অস্থায়ী std::string বানায় — লেখা লম্বা হলে heap-এ মেমরি চেয়ে, অক্ষর কপি করে — শুধু reference দেওয়ার জন্য। C++17 এর সমাধান দিয়েছে std::string_view — header <string_view>-এ।

একটি string_view-এর ভেতরে শুধু দুটি সংখ্যা — লেখার শুরুর ঠিকানা আর দৈর্ঘ্য; 64-bit সিস্টেমে মোট ১৬ byte. এটি std::string, string literal বা অন্য কোনো char-এর সারির দিকে তাকাতে পারে, কোনো কপি ছাড়াই। আর এর substr নতুন লেখা বানায় না, শুধু ঠিকানা আর দৈর্ঘ্য বদলে নতুন একটি view দেয়। find, size, starts_with, তুলনা — শুধু পড়ার প্রায় সব ফাংশনই আছে। নেই শুধু বদলানোর ফাংশন: +=, insert, replace.

// শুধু পড়ে, তাই string_view: std::string, literal — সবই কপি ছাড়া চলে
std::size_t countDigits(std::string_view text) {
    std::size_t n = 0;
    for (char c : text) if (c >= '0' && c <= '9') ++n;
    return n;
}
countDigits("Road 12, House 7");      // কোনো std::string তৈরি হয় না
countDigits(addressString);           // std::string থেকেও সরাসরি

কিন্তু “শুধু দেখা” মানে মালিকানা নেই — আর মালিকানা না থাকলে মালিকের আয়ুর ওপর পুরো নির্ভরতা। এটাই string_view-এর বিপদ, আর পর্ব ১০-এর dangling reference-এর মতোই এটি compile হয়, অনেক সময় চলেও। নিচের কোডে একটি নিরাপদ ব্যবহার আর দুটি ভুল আছে। ধাপে ধাপে দেখুন:

1std::string city = "Dhaka-1205";2std::string_view v = city;3std::string_view code = v.substr(6);4std::string_view bad = std::string("Sylhet") + "-3100";5std::println("{}", bad);         // undefined behavior6city += " Bangladesh";           // v আর code অবৈধ

কখন string_view, কখন নয়

View-এর আরেকটি ফাঁদ হলো std::string_view sv = getName();, যেখানে getName() একটি std::string by value ফেরত দেয় — এটিও temporary-র দিকে view. Clang-এর মতো compiler প্রায়ই এখানে সতর্কবার্তা দেয়, কিন্তু সব ক্ষেত্রে ধরতে পারে না। কোন object কতক্ষণ বাঁচে, পুরো ছবিটি পর্ব ১৮-এ “lifetime” নামে দেখবেন; আর ঠিকানা জিনিসটা আসলে কী, তা পরের পর্বে pointer দিয়ে।

৮ · বাংলা লেখা — byte, code point আর অক্ষর

এ পর্যন্ত সব উদাহরণ ইংরেজিতে ছিল, যেখানে একটি char = একটি অক্ষর। বাংলায় এই সরল হিসাব ভেঙে যায়। কারণ std::string আসলে অক্ষর চেনে না — সে শুধু byte-এর একটি সারি রাখে। সেই byte-গুলোর অর্থ কী, তা ঠিক করে একটি encoding, আর আজকের প্রায় সব বাংলা লেখা থাকে UTF-8-এ।

প্রথমে Unicode: এটি পৃথিবীর প্রায় সব লিপির প্রতিটি চিহ্নকে একটি নম্বর দেয়, যাকে বলে code point. বাংলার নম্বরগুলো U+0980 থেকে U+09FF-এর মধ্যে। UTF-8 সেই নম্বরকে ১ থেকে ৪ byte-এ লেখে: ইংরেজি বর্ণ (ASCII) ১ byte-এ, আর বাংলার প্রতিটি code point ৩ byte-এ। "বাংলা" শব্দটিকে byte ধরে ধরে খুলে দেখুন:

লেখা:        বাংলা
code point:  ব      া      ং      ল      া
নম্বর:       U+09AC U+09BE U+0982 U+09B2 U+09BE
             ৫টি code point  (কার-চিহ্নও আলাদা code point)

index:  0  1  2 | 3  4  5 | 6  7  8 | 9 10 11 |12 13 14
byte:  E0 A6 AC |E0 A6 BE |E0 A6 82 |E0 A6 B2 |E0 A6 BE
        ব       |   া     |   ং     |   ল     |   া
bn.size() == 15   <- byte, অক্ষর নয়

bn[0] == 0xE0     (x86-এ char signed, তাই মান -32)
এটি "ব" নয় — "ব"-এর ৩ byte-এর প্রথমটি
একা ছাপলে terminal দেখায় অচেনা চিহ্ন: �

byte:  E0 A6 AC | E0 A6 BE ...
        ব       | ভাঙা
ফল: "ব" + অসম্পূর্ণ একটি byte -> ভুল UTF-8
bn.substr(0, 3) == "ব"   <- byte-এর হিসাবে কাটলে ঠিক

প্রথম byte: E0 (1110xxxx)   পরের byte: A6, AC (10xxxxxx)
for (unsigned char b : bn)
    if ((b & 0xC0) != 0x80) ++count;   // "10xxxxxx" বাদ
count == 5   (কিন্তু পাঠক দেখেন বাং + লা)

char8_t, u8 আর বড় হাত-ছোট হাত

C++20 একটি আলাদা টাইপ এনেছে, char8_t, যার অর্থ “এই byte UTF-8 লেখার অংশ”। u8"বাংলা" literal-এর টাইপ C++20 থেকে const char8_t-এর array, আর এর জন্য আছে std::u8string. উদ্দেশ্য ভালো — টাইপ দেখেই encoding বোঝা। কিন্তু বাস্তবে std::cout, std::format বা বেশিরভাগ লাইব্রেরি এখনো সাধারণ char চায়, তাই অনেক দল সাধারণ std::string-এই UTF-8 রাখে আর ফাইল UTF-8-এ সেভ করে। আপনিও এখন সেটাই করুন; terminal-এ বাংলা দেখানোর ঝামেলা পর্ব ০৭-এর শেষ অংশে দেখেছেন।

আরেকটি সৎ সতর্কতা: <cctype>-এর std::toupper আর std::tolower শুধু একটি byte দেখে, তাই এগুলো শুধু ASCII ইংরেজি বর্ণে নির্ভরযোগ্য। বাংলায় বড় হাত-ছোট হাত নেই, কিন্তু তুর্কি বা জার্মানের মতো ভাষায় এক byte ধরে বদলানো ভুল ফল দেয়। আর ব্যবহারের সময় char-কে আগে unsigned char-এ বদলে নিন — std::toupper(static_cast<unsigned char>(c)) — কারণ ঋণাত্মক মান (যেমন বাংলার byte 0xE0 = -32) দিলে ফল undefined behavior.

৯ · AI-এর যুগে — লেখা নিয়ে AI-এর চেনা ভুল

লেখা-সংক্রান্ত কোড AI খুব দ্রুত লিখে দেয়, কিন্তু তার শেখার উৎসে প্রচুর পুরোনো C-ধাঁচের কোড আর ইংরেজি-কেন্দ্রিক উদাহরণ আছে। ফলে ভুলগুলো প্রায় একই রকম ফিরে আসে — আর বেশিরভাগই ছোট ইংরেজি ইনপুটে ধরা পড়ে না। বাংলা নাম, ফাঁকা ঘর বা লম্বা ইনপুট দিলেই ভাঙে।

AI-এর লেখা string-কোড যাচাইয়ের চেকলিস্ট

• কোডে কোনো char[], strcpy, strcat, sprintf বা gets নেই; থাকলে কারণটা বলতে পারি (যেমন একটি C লাইব্রেরি ডাকা)
• প্রতিটি string_view-এর জন্য বলতে পারি — অক্ষরগুলোর মালিক কে, আর view-এর চেয়ে সে বেশি দিন বাঁচে কি না; view থাকা অবস্থায় মালিক বদলায় না
• প্রতিটি find/rfind-এর ফল npos-এর সাথে মেলানো হয়েছে, আর ফল auto বা std::size_t-এ রাখা
• প্রতিটি stoi/stod হয় try/catch-এর ভেতরে, নয়তো বদলে from_chars আর ec যাচাই
• বাংলা নাম দিয়ে চালিয়ে দেখেছি — size(), substr বা s[i] কোথাও অক্ষর ভেঙে দিচ্ছে না
• -fsanitize=address দিয়ে চালিয়েছি; dangling view বা সীমার বাইরে পড়া থাকলে এটি সাধারণত ধরে ফেলে