தனிப்பயன் கட்டமைப்புகளுடன் சி ++ வரிசைகளில் நினைவக கசிவுகளைத் தடுப்பது

சி ++ வரிசைகளில் நினைவக நடத்தையைப் புரிந்துகொள்வது

சி ++ இல் நினைவக மேலாண்மை ஒரு முக்கியமான தலைப்பு, குறிப்பாக மாறும் ஒதுக்கீடுகளைக் கையாளும் போது. டெவலப்பர்கள் எதிர்கொள்ளும் ஒரு பொதுவான பிரச்சினை நினைவக கசிவுகள் ஆகும், இது ஒதுக்கப்பட்ட நினைவகம் சரியாக சமாளிக்கப்படாதபோது நிகழ்கிறது. .

இந்த சூழ்நிலையில், நாங்கள் ஒரு தனிப்பயன் கட்டமைப்புடன் (`செய்தி`) உடன் பணிபுரிகிறோம், இது மாறும் ஒதுக்கப்பட்ட எழுத்து வரிசையைக் கொண்டுள்ளது. இந்த கட்டமைப்பு பின்னர் ஒரு `std :: Queue` க்குள் தள்ளப்படுகிறது, இது ஒரு நகல் கட்டமைப்பாளரை தூண்டுகிறது. இருப்பினும், `மெம்மோவ் ()` ஐப் பயன்படுத்திய பிறகு, நினைவக முகவரிகள் எதிர்பார்ப்புகளுடன் பொருந்தவில்லை.

பல சி ++ டெவலப்பர்கள் இதே போன்ற சிக்கல்களை எதிர்கொள்கின்றனர், குறிப்பாக சுட்டிகள் மற்றும் குவியல் நினைவகம் உடன் பணிபுரியும் போது. தவறான நிர்வாகம் தொங்கும் சுட்டிகள், நினைவக துண்டு துண்டாக அல்லது நிரல் செயலிழப்புகளுக்கு வழிவகுக்கும் . எனவே, வலுவான மற்றும் திறமையான குறியீட்டை எழுதுவதற்கு நினைவகம் ஏன் மாற்றத்தை மாற்றுவது அவசியம்.

இந்த கட்டுரை நினைவக இருப்பிடம் ஏன் மாறுகிறது என்பதையும், மாறும் ஒதுக்கப்பட்ட வரிசையுடன் வரிசையைப் பயன்படுத்தும் போது நினைவக கசிவுகளை நாம் எவ்வாறு தடுக்க முடியும் என்பதையும் ஆராய்கிறது. நாங்கள் சிக்கலை உடைப்போம், சரியான நகல் சொற்பொருள் பற்றிய நுண்ணறிவுகளை வழங்குவோம், மேலும் சி ++ இல் நினைவகத்தைக் கையாள்வதற்கான சிறந்த நடைமுறைகளைப் பற்றி விவாதிப்போம். .

சி ++ வரிசைகளில் நினைவக நிர்வாகத்தில் ஆழமாக டைவ் செய்யுங்கள்

முன்னர் வழங்கப்பட்ட ஸ்கிரிப்ட்களில், சி ++ இல் ஒரு பொதுவான சிக்கலை நாங்கள் கையாண்டோம்: நினைவக கசிவுகள் மற்றும் தவறான நினைவக மேலாண்மை வரிசைகள் உள்ளே மாறும் ஒதுக்கீடுகளைக் கையாளும் போது. முதல் ஸ்கிரிப்ட் நினைவக ஒதுக்கீடு மற்றும் ஒப்பந்த இடத்தை கைமுறையாக கையாளுகிறது, இரண்டாவதாக ஸ்மார்ட் சுட்டிகள் ஐப் பயன்படுத்தி இந்த செயல்முறையை மேம்படுத்துகிறது. இரண்டு அணுகுமுறைகளும் தற்செயலான நினைவக கசிவுகளைத் தடுப்பதற்கும் சரியான நினைவக நிர்வாகத்தை உறுதி செய்வதற்கும் வழிகளை நிரூபிக்கின்றன. .

இங்கே முக்கிய பிரச்சினை என்னவென்றால், ஒரு பொருள் `std :: Queue` க்குள் தள்ளப்படும்போது, ​​அது நகலெடுக்க அல்லது செயல்பாடுகளை நகர்த்துகிறது . சரியான நகல் கட்டமைப்பாளர் மற்றும் ஒதுக்கீட்டு ஆபரேட்டர் ஐ நாங்கள் வரையறுக்கவில்லை என்றால், இயல்புநிலை ஆழமற்ற நகல் பல பொருள்களை ஒரே நினைவகத்தைக் குறிப்பிடக்கூடும், இது சுட்டிகள் அல்லது எதிர்பாராத நடத்தைக்கு வழிவகுக்கும். ஆழமான பிரதிகள் ஐப் பயன்படுத்துவது, எங்கள் ஸ்கிரிப்ட்களில் காட்டப்பட்டுள்ளபடி, ஒவ்வொரு பொருளுக்கும் அதன் சொந்த நினைவக ஒதுக்கீடு இருப்பதை உறுதி செய்கிறது, திட்டமிடப்படாத பக்க விளைவுகளைத் தவிர்க்கிறது.

இரண்டாவது ஸ்கிரிப்ட்டில் குறிப்பிடத்தக்க முன்னேற்றங்களில் ஒன்று `std :: bendic_ptr` ஐப் பயன்படுத்துவதாகும், இது பொருள் வரம்பிலிருந்து வெளியேறும்போது தானாகவே நினைவகத்தை கையாளுகிறது. இது வெளிப்படையான `நீக்கு []` அழைப்புகள் மற்றும் நினைவகம் திறமையாக நிர்வகிக்கப்படுவதை உறுதி செய்கிறது. `Std :: make_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;
}

நினைவக முகவரி சி ++ வரிசைகளில் மாற்றங்களைப் புரிந்துகொள்வது

c ++ வரிசைகள் மற்றும் மாறும் ஒதுக்கப்பட்ட நினைவகத்துடன் பணிபுரியும் போது, ​​ஒரு எதிர்பாராத நடத்தை என்பது பொருள்களை வரிசையில் தள்ளும்போது நினைவக முகவரிகளில் மாற்றம் ஆகும். இது நிகழ்கிறது, ஏனெனில் வரிசை குறிப்புகளை சேமிப்பதை விட பொருள்களின் நகல்களை உருவாக்குகிறது. ஒவ்வொரு முறையும் ஒரு பொருள் நகலெடுக்கப்படும்போது, ​​எந்தவொரு மாறும் ஒதுக்கப்பட்ட உறுப்பினர்களுக்கும் புதிய நினைவக ஒதுக்கீடு நிகழ்கிறது, இது வெவ்வேறு நினைவக முகவரிகளுக்கு வழிவகுக்கிறது.

எங்கள் எடுத்துக்காட்டில் உள்ள ஒரு முக்கிய பிரச்சினை என்னவென்றால், சார் வரிசை (`தரவு`) குவியலில் ஒதுக்கப்பட்டுள்ளது , ஆனால் பொருள் நகலெடுக்கப்படும்போது, ​​அசல் மற்றும் நகல் ஒரே நினைவக இடத்தைப் பகிரவில்லை. இதனால்தான் `தரவின்` முகவரியை வரிசையில் தள்ளுவதற்கு முன்னும் பின்னும் அச்சிடும்போது, ​​மதிப்புகள் வேறுபடுகின்றன. இந்த சிக்கலுக்கான தீர்வு நகர்த்து சொற்பொருள் `std :: நகர்த்து ()` உடன் பயன்படுத்துவது, இது தரவை நகலெடுப்பதற்கு பதிலாக உரிமையை மாற்றுகிறது. மற்றொரு அணுகுமுறை `std :: பகிரப்பட்ட_பிடிஆர்` அல்லது` எஸ்.டி.டி :: தனித்துவமான_பிடிஆர்` போன்ற ஸ்மார்ட் சுட்டிகள் ஐப் பயன்படுத்துவது, சிறந்த நினைவக நிர்வாகத்தை உறுதி செய்கிறது.

நிஜ-உலக பயன்பாடுகளில், நெட்வொர்க்கிங் அல்லது நிகழ்நேர தரவு செயலாக்கம் இல் இத்தகைய நினைவக நடத்தை முக்கியமானது, அங்கு ஒரு அமைப்பின் வெவ்வேறு பகுதிகளுக்கு இடையில் அனுப்பும் செய்தியைக் கையாள வரிசைகள் அடிக்கடி பயன்படுத்தப்படுகின்றன. Rep ஒழுங்காக நிர்வகிக்கப்படாவிட்டால், அதிகப்படியான நினைவக ஒதுக்கீடுகள் மற்றும் ஆழமான பிரதிகள் கடுமையாக பாதிக்கப்படும் செயல்திறன் . சி ++ ஹூட்டின் கீழ் நினைவகத்தை எவ்வாறு நிர்வகிக்கிறது என்பதைப் புரிந்துகொள்வது டெவலப்பர்களை திறமையான, உகந்த மற்றும் பிழை இல்லாத குறியீட்டை எழுத அனுமதிக்கிறது. .