ഇഷ്ടാനുസൃത രൂപങ്ങൾ ഉപയോഗിച്ച് സി ++ ക്യൂകളിൽ മെമ്മറി ചോർച്ച തടയുന്നു

സി ++ ക്യൂകളിൽ മെമ്മറി പെരുമാറ്റം മനസ്സിലാക്കുക

സി ++ ലെ മെമ്മറി മാനേജുമെന്റ് ഒരു നിർണായക വിഷയമാണ്, പ്രത്യേകിച്ചും ഡൈനാമിക് അലോക്കേഷനുകളെ കൈകാര്യം ചെയ്യുമ്പോൾ. ഡവലപ്പർമാർ മുഖം മെമ്മറി ലീക്കുകൾ ആണെന്ന് ഒരു പൊതുവായ പ്രശ്നം പതനം

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഒരു ഇഷ്ടാനുസൃത ഘടന (`സന്ദേശം`) ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു അതിൽ ചലനാത്മകമായി അനുവദിച്ച പ്രതീക അറേ അടങ്ങിയിരിക്കുന്നു. ഈ ഘടന ഒരു `std :: ക്യൂ 'ലേക്ക് നയിക്കുന്നു, ഒരു പകർപ്പ് കൺസ്ട്രക്റ്റർ സൃഷ്ടിക്കുന്നു . എന്നിരുന്നാലും, `മെമ്മോവ് ()` ഉപയോഗിച്ചതിനുശേഷം, മെമ്മറി വിലാസങ്ങൾ പ്രതീക്ഷകളെ പൊരുത്തപ്പെടുന്നില്ല.

പല സി ++ ഡവലപ്പർമാർക്കും സമാനമായ പ്രശ്നങ്ങൾ നേരിടുന്നു, പ്രത്യേകിച്ചും പോയിന്ററുകളും ഹീപ് മെമ്മറിയും ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ . അപശ്രാദായം തൂക്കമില്ലാത്ത പോയിന്ററുകൾ, മെമ്മറി ക്രീംമെന്റേഷൻ, അല്ലെങ്കിൽ പ്രോഗ്രാം ക്രാഷുകൾ എന്നിവയിലേക്ക് നയിച്ചേക്കാം . അതിനാൽ, കരുത്തുറ്റതും കാര്യക്ഷമവുമായ കോഡ് എഴുതുന്നതുകൊണ്ട് മെമ്മറി വിലാസങ്ങൾ മാറുന്നത് അത്യാവശ്യമാണെന്ന് മനസ്സിലാക്കുക.

ഈ ലേഖനം മെമ്മറി ലൊക്കേഷൻ മാറ്റങ്ങൾ വരുത്തുന്നത് എന്തുകൊണ്ടെന്ന് പര്യവേക്ഷണം ചെയ്യുന്നു. ഞങ്ങൾ പ്രശ്നം തകർക്കും, ഉൾക്കാഴ്ച ശരിയായ പകർപ്പ് സെമാന്തിക്സിൽ , സി ++ ൽ മെമ്മറി കൈകാര്യം ചെയ്യുന്നതിനുള്ള മികച്ച പരിശീലനങ്ങൾ ചർച്ച ചെയ്യുക. പതനം

സി ++ ക്യൂകളിൽ മെമ്മറി മാനേജുമെന്റിലേക്ക് ആഴത്തിലുള്ള മുവൻ

നേരത്തെ നൽകിയ സ്ക്രിപ്റ്റുകളിൽ, സി ++: മെമ്മറി ലീക്കുകളും തെറ്റായ മെമ്മറി മാനേജുമെന്റും ക്യൂവിനുള്ളിൽ ഡൈനാമിക് അലോക്കേഷനുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ . ആദ്യ സ്ക്രിപ്റ്റ് മെമ്മറി അലോക്കേഷനും ഡീലോക്കേഷനും സ്വമേധയാ കൈകാര്യം ചെയ്യുന്നു, രണ്ടാമത്തേത് സ്മാർട്ട് പോയിന്ററുകൾ ഉപയോഗിച്ച് ഈ പ്രക്രിയയെ ഒപ്റ്റിമൈസ് ചെയ്യുന്നു . രണ്ട് സമീപനങ്ങളും മന int പൂർവ്വമല്ലാത്ത മെമ്മറി ലീക്കുകൾ തടയുന്നതിനും ശരിയായ മെമ്മറി മാനേജുമെന്റ് ഉറപ്പാക്കുന്നതിനും പ്രകടമാക്കുന്നു. പതനം

ഒരു വസ്തുവിനെ `std :: ക്യൂ 'ലേക്ക് നയിക്കുന്നതാണ് ഇവിടെ പ്രധാന പ്രശ്നം, അത് പകർത്തുക അല്ലെങ്കിൽ പ്രവർത്തനങ്ങൾ . ഞങ്ങൾ ഒരു ശരിയായ നിർവചിക്കുന്നില്ലെങ്കിൽ, കൺസ്ട്രക്റ്റർ, അസൈൻമെന്റ് ഓപ്പറേറ്റർ പകർത്തുകയാണെങ്കിൽ , സ്ഥിരസ്ഥിതി ആഴമില്ലാത്ത പകർപ്പ് ഒരേ മെമ്മറി പരാമർശിക്കാൻ ഒന്നിലധികം ഒബ്ജക്റ്റുകൾക്ക് കാരണമാകും, തൂങ്ങിക്കിടക്കുന്ന അല്ലെങ്കിൽ അപ്രതീക്ഷിത പെരുമാറ്റത്തിലേക്ക് നയിക്കുന്നു. ആഴത്തിലുള്ള പകർപ്പുകൾ ഉപയോഗിക്കുന്നു , ഞങ്ങളുടെ സ്ക്രിപ്റ്റുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ഓരോ വസ്തുവിനും അതിന്റേതായ മെമ്മറി അലോക്കേഷൻ ഉണ്ടെന്ന് ഉറപ്പാക്കുന്നു, ആന്തരികമായി പാർശ്വഫലങ്ങൾ ഒഴിവാക്കുന്നു.

രണ്ടാമത്തെ തിരക്കഥയിലെ ഒരു പ്രധാന മെച്ചപ്പെടുത്തലുകളിൽ ഒന്ന് `std :: ന്റെ ഉപയോഗത്തിന് പുറത്തുപോകുമ്പോൾ സ്വപ്രേരിതമായി ഡീലോകേറ്റ് ചെയ്യുന്നു. ഇത് വ്യക്തമായ `ഇല്ലാതാക്കേണ്ട ആവശ്യകതയെ തടയുന്നു` ഇല്ലാതാക്കുക [] കോളുകളും മെമ്മറി കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. `Std :: met_unique, ഞങ്ങൾ നേടുന്നു ഒഴിവാക്കൽ സുരക്ഷ എന്നിവയും ഞങ്ങൾ നേടുന്നു , അലോക്കേഷൻ പരാജയപ്പെട്ടാൽ ചോർച്ച തടയുന്നു. ഈ ആശയത്തിന്റെ വലിയ യഥാർത്ഥ ജീവിത ഉദാഹരണം ഗെയിം എഞ്ചിനുകൾ ടെക്സ്ചർ ഡാറ്റ നിയന്ത്രിക്കുക , എവിടെയാണ് ധനപരമായി അനുവദിച്ച ഉറവിടങ്ങൾ ഇനി ആവശ്യമില്ലാത്തപ്പോൾ മോചിപ്പിക്കേണ്ടത്. പതനം

മൊത്തത്തിൽ, രണ്ട് സമീപനങ്ങളും പ്രശ്നം ഫലപ്രദമായി പരിഹരിക്കുന്നു, പക്ഷേ സ്മാർട്ട് പോയിന്റർ സമീപനം മികച്ച പരിശീലനമാണ് അതിന്റെ സുരക്ഷ കാരണം, മാനുവൽ മെമ്മറി കൈകാര്യം ചെയ്യൽ കുറയ്ക്കുന്നു. നിങ്ങൾ ഒരു പ്രകടന-നിർണായക ആപ്ലിക്കേഷനിൽ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ , തത്സമയ ഡാറ്റ പ്രോസസ്സിംഗ് അല്ലെങ്കിൽ ഉൾച്ചേർത്ത സിസ്റ്റങ്ങൾ പോലുള്ളവ, സി ++ ലെ മെമ്മറി മാനേജുമെന്റ് മാസ്റ്റർ ചെയ്യുന്ന മെമ്മറി മാനേജുമെന്റ് അത്യാവശ്യമാണ്. ക്യൂവിൽ , ഡവലപ്പർമാർക്ക് , ഡവലപ്പർമാർക്ക് വിവിധ സാഹചര്യങ്ങളിൽ കാര്യക്ഷമമായി അവതരിപ്പിക്കുന്ന കരുത്തുറ്റവയ്ക്കാണ് കരുണകൾക്ക് കരുത്തുറ്റ വരും. പതനം

#include <iostream>
#include <queue>
struct Message {
    char* data = nullptr;
    size_t size = 0;
    Message() = default;
    ~Message() { delete[] data; }
    Message(const Message& other) {
        size = other.size;
        data = new char[size];
        std::memcpy(data, other.data, size);
    }
    Message& operator=(const Message& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new char[size];
            std::memcpy(data, other.data, size);
        }
        return *this;
    }
};
int main() {
    std::queue<Message> message_queue;
    Message msg;
    msg.size = 50;
    msg.data = new char[msg.size];
    message_queue.push(msg);
    Message retrieved = message_queue.front();
    message_queue.pop();
    return 0;
}

#include <iostream>
#include <queue>
#include <memory>
struct Message {
    std::unique_ptr<char[]> data;
    size_t size = 0;
    Message() = default;
    Message(size_t s) : size(s), data(std::make_unique<char[]>(s)) {}
    Message(const Message& other) : size(other.size), data(std::make_unique<char[]>(other.size)) {
        std::memcpy(data.get(), other.data.get(), size);
    }
    Message& operator=(const Message& other) {
        if (this != &other) {
            size = other.size;
            data = std::make_unique<char[]>(size);
            std::memcpy(data.get(), other.data.get(), size);
        }
        return *this;
    }
};
int main() {
    std::queue<Message> message_queue;
    Message msg(50);
    message_queue.push(msg);
    Message retrieved = message_queue.front();
    message_queue.pop();
    return 0;
}

സി ++ ക്യൂകളിൽ മെമ്മറി വിലാസം മനസ്സിലാക്കൽ

സി ++ ക്യൂ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ, ചലനാത്മകമായി അനുവദിച്ച മെമ്മറി, ഒരു അപ്രതീക്ഷിത പെരുമാറ്റം വസ്തുക്കളെ ഒരു ക്യൂവിലേക്ക് തള്ളുമ്പോൾ മെമ്മറി വിലാസങ്ങളിലെ മാറ്റം മാറ്റുന്നു. ഇത് സംഭവിക്കുന്നു, കാരണം ക്യൂ റഫറൻസുകൾ സംഭരിക്കുന്നതിനേക്കാൾ പകർപ്പുകൾ പകർപ്പുകൾ സൃഷ്ടിക്കുന്നു. ഓരോ തവണയും ഒരു ഒബ്ജക്റ്റ് പകർത്തിയ ഓരോ തവണയും, ഒരു പുതിയ മെമ്മറി അലോക്കേഷനും വ്യത്യസ്ത മെമ്മറി വിലാസങ്ങളിലേക്ക് നയിക്കുന്നതിന് സംഭവിക്കുന്നു.

ഞങ്ങളുടെ ഉദാഹരണത്തിലെ ഒരു പ്രധാന പ്രശ്നം ചാർ അറേ ('ഡാറ്റ`) കൂമ്പാരത്തിൽ അനുവദിക്കുന്നു എന്നതാണ് , പക്ഷേ ഒബ്ജക്റ്റ് പകർത്തിയപ്പോൾ, ഒറിജിനലും പകർപ്പവും ഒരേ മെമ്മറി ഇടം പങ്കിടുന്നില്ല എന്നതാണ്. അതിനാലാണ് വസ്തുവിനെ ക്യൂവിലേക്ക് തള്ളിവിടുന്നതിന് മുമ്പും ശേഷവും ഞങ്ങൾ വിലാസം അച്ചടിക്കുമ്പോൾ, മൂല്യങ്ങൾ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. ഈ പ്രശ്നത്തിനുള്ള പരിഹാരം നീക്കുക സെമാന്റിക്സ് ഉപയോഗിച്ച് ഉപയോഗിക്കുക എന്നതാണ് `std :: നീക്കുക () നീക്കുക ()` എന്നിവ ഉപയോഗിച്ച് () `എന്നിവ ഉപയോഗിച്ച് ()`, ഇത് ഉടമസ്ഥാവകാശം പകർത്തുന്നു. മറ്റൊരു സമീപനം സ്മാർട്ട് പോയിന്ററുകൾ ഉപയോഗിക്കുക എന്നതാണ് `std :: std :: std:` std :: std :: std :: std :.

യഥാർത്ഥ ലോക ആപ്ലിക്കേഷനുകളിൽ, അത്തരം മെമ്മറി പെരുമാറ്റം നെറ്റ്വർക്കിംഗ് നെറ്റ്വർക്കിംഗിൽ അല്ലെങ്കിൽ തത്സമയ ഡാറ്റ പ്രോസസ്സിംഗ് , ഒരു സിസ്റ്റത്തിന്റെ വിവിധ ഭാഗങ്ങൾക്കിടയിൽ വിജയങ്ങൾ ഇടപഴകുന്നതിനായി ക്യൂകൾ പതിവായി ഉപയോഗിക്കുന്നു. 🚀 ശരിയായി കൈകാര്യം ചെയ്തിട്ടില്ലെങ്കിൽ, അമിതമായ മെമ്മറി അലോക്കേഷനും ആഴത്തിലുള്ള പകർപ്പുകൾക്കും പ്രകടനം . സി ++ മാനേജർ മെമ്മറി ഹുഡിന് കീഴിൽ എങ്ങനെയുള്ളതാണെന്ന് മനസിലാക്കുന്നു കാര്യക്ഷമവും ഒപ്റ്റിമൈസ് ചെയ്തതും ബഗ് രഹിതവുമായ കോഡ്. പതനം