ಕಸ್ಟಮ್ ರಚನೆಗಳೊಂದಿಗೆ ಸಿ ++ ಕ್ಯೂಗಳಲ್ಲಿ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಯುವುದು

ಸಿ ++ ಕ್ಯೂಗಳಲ್ಲಿ ಮೆಮೊರಿ ನಡವಳಿಕೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಿ ++ ನಲ್ಲಿನ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಒಂದು ನಿರ್ಣಾಯಕ ವಿಷಯವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಕ್ರಿಯಾತ್ಮಕ ಹಂಚಿಕೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಡೆವಲಪರ್‌ಗಳು ಎದುರಿಸುತ್ತಿರುವ ಒಂದು ಸಾಮಾನ್ಯ ವಿಷಯವೆಂದರೆ ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು , ನಿಗದಿಪಡಿಸಿದ ಮೆಮೊರಿಯನ್ನು ಸರಿಯಾಗಿ ವಿತರಿಸದಿದ್ದಾಗ ಸಂಭವಿಸುತ್ತದೆ. 🚀

ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, ನಾವು ಕಸ್ಟಮ್ ಸ್ಟ್ರಕ್ಟ್ (`ಮೆಸೇಜ್`) ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ, ಅದು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ಒಳಗೊಂಡಿದೆ. ಈ ರಚನೆಯನ್ನು ನಂತರ `STD :: ಕ್ಯೂ''ಗೆ ತಳ್ಳಲಾಗುತ್ತದೆ, ಇದು ನಕಲು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, `ಮೆಮೋವ್ ()` ಅನ್ನು ಬಳಸಿದ ನಂತರ, ಮೆಮೊರಿ ವಿಳಾಸಗಳು ನಿರೀಕ್ಷೆಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ.

ಅನೇಕ ಸಿ ++ ಡೆವಲಪರ್‌ಗಳು ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸುತ್ತಾರೆ, ವಿಶೇಷವಾಗಿ ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ರಾಶಿ ಮೆಮೊರಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ . ದುರುಪಯೋಗವು ಡ್ಯಾಂಗ್ಲಿಂಗ್ ಪಾಯಿಂಟರ್‌ಗಳು, ಮೆಮೊರಿ ವಿಘಟನೆ ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್‌ಗಳು ಗೆ ಕಾರಣವಾಗಬಹುದು. ಹೀಗಾಗಿ, ದೃ and ವಾದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಬರೆಯಲು ಮೆಮೊರಿ ವಿಳಾಸ ಬದಲಾವಣೆಯನ್ನು ಏಕೆ ತಿಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.

ಈ ಲೇಖನವು ಮೆಮೊರಿ ಸ್ಥಳವು ಏಕೆ ಬದಲಾಗುತ್ತದೆ ಮತ್ತು ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ನಾವು ಹೇಗೆ ತಡೆಯಬಹುದು ಎಂಬುದನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಶ್ರೇಣಿಯೊಂದಿಗೆ ಕ್ಯೂ ಬಳಸುವಾಗ . ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಮುರಿಯುತ್ತೇವೆ, ಸರಿಯಾದ ನಕಲು ಶಬ್ದಾರ್ಥ ನ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸುತ್ತೇವೆ ಮತ್ತು ಸಿ ++ ನಲ್ಲಿ ಸ್ಮರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ. 💡 💡 💡

ಸಿ ++ ಕ್ಯೂಗಳಲ್ಲಿ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗೆ ಆಳವಾಗಿ ಧುಮುಕುವುದಿಲ್ಲ

ಮೊದಲೇ ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ, ನಾವು ಸಿ ++ ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯನ್ನು ನಿಭಾಯಿಸಿದ್ದೇವೆ: ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು ಮತ್ತು ತಪ್ಪಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಕ್ಯೂಗಳ ಒಳಗೆ ಕ್ರಿಯಾತ್ಮಕ ಹಂಚಿಕೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ವ್ಯವಹಾರವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಎರಡನೆಯದು ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಿ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ. ಎರಡೂ ವಿಧಾನಗಳು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಗಟ್ಟುವ ಮತ್ತು ಸರಿಯಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮಾರ್ಗಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ. 🚀

ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯವೆಂದರೆ ವಸ್ತುವನ್ನು `STD :: ಕ್ಯೂ'ಗೆ ತಳ್ಳಿದಾಗ, ಅದು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಕಲಿಸಿ ಅಥವಾ ಸರಿಸಿ ಗೆ ಒಳಗಾಗುತ್ತದೆ. ನಾವು ಸರಿಯಾದ ಕಾಪಿ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಮತ್ತು ಅಸೈನ್ಮೆಂಟ್ ಆಪರೇಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ, ಡೀಫಾಲ್ಟ್ ಆಳವಿಲ್ಲದ ನಕಲು ಒಂದೇ ಮೆಮೊರಿಯನ್ನು ಉಲ್ಲೇಖಿಸಲು ಅನೇಕ ವಸ್ತುಗಳು ಕಾರಣವಾಗಬಹುದು, ಇದು ತೂಗಾಡುತ್ತಿರುವ ಪಾಯಿಂಟರ್‌ಗಳು ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ವರ್ತನೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಆಳವಾದ ಪ್ರತಿಗಳನ್ನು ಬಳಸುವುದು , ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ, ಪ್ರತಿ ವಸ್ತುವಿಗೆ ತನ್ನದೇ ಆದ ಮೆಮೊರಿ ಹಂಚಿಕೆಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅನಪೇಕ್ಷಿತ ಅಡ್ಡಪರಿಣಾಮಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಎರಡನೆಯ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಗಮನಾರ್ಹ ಸುಧಾರಣೆಯೆಂದರೆ `std :: Unice_ptr` ನ ಬಳಕೆ, ಇದು ವಸ್ತುವು ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಬಂದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಮರಣೆಯನ್ನು ಡಯಲ್ಲೋಕೇಟ್ ಮಾಡುತ್ತದೆ. ಇದು ಸ್ಪಷ್ಟವಾದ `ಅಳಿಸು []` ಕರೆಗಳ ಅಗತ್ಯವನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಮೆಮೊರಿಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. `Std :: make_unick` ಅನ್ನು ಬಳಸುವುದರ ಮೂಲಕ, ನಾವು ವಿನಾಯಿತಿ ಸುರಕ್ಷತೆಯನ್ನು ಸಹ ಪಡೆಯುತ್ತೇವೆ, ಹಂಚಿಕೆ ವೈಫಲ್ಯಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಯುತ್ತೇವೆ. ಈ ಪರಿಕಲ್ಪನೆಯ ಉತ್ತಮ ನೈಜ-ಜೀವನದ ಉದಾಹರಣೆಯೆಂದರೆ ಗೇಮ್ ಎಂಜಿನ್‌ಗಳು ವಿನ್ಯಾಸದ ಡೇಟಾವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತವೆ , ಅಲ್ಲಿ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಬೇಕು. 🎮

ಒಟ್ಟಾರೆಯಾಗಿ, ಎರಡೂ ವಿಧಾನಗಳು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಹರಿಸುತ್ತವೆ, ಆದರೆ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್ ವಿಧಾನವು ಅದರ ಸುರಕ್ಷತೆ ಮತ್ತು ಕಡಿಮೆ ಹಸ್ತಚಾಲಿತ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯಿಂದಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ . ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸಂಸ್ಕರಣೆ ಅಥವಾ ಎಂಬೆಡೆಡ್ ಸಿಸ್ಟಮ್‌ಗಳಂತಹ ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಅಪ್ಲಿಕೇಶನ್ ನಲ್ಲಿ ನೀವು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಸಿ ++ ನಲ್ಲಿ ಮಾಸ್ಟರಿಂಗ್ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಅತ್ಯಗತ್ಯ. ಕ್ಯೂಸ್ ನಲ್ಲಿ ವಸ್ತುಗಳನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸರಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ವಿವಿಧ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ದೃ ust ವಾದ, ಸೋರಿಕೆ-ಮುಕ್ತ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು. 💡

#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 :: MOVE ()` ನೊಂದಿಗೆ ಬಳಸುವುದು, ಇದು ಡೇಟಾವನ್ನು ನಕಲಿಸುವ ಬದಲು ಮಾಲೀಕತ್ವವನ್ನು ವರ್ಗಾಯಿಸುತ್ತದೆ. ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ `STD :: WARD_PTR` ಅಥವಾ` STD :: UNICE_PTR` ನಂತಹ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು, ಉತ್ತಮ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.

ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ನೆಟ್‌ವರ್ಕಿಂಗ್ ಅಥವಾ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸಂಸ್ಕರಣೆಯಲ್ಲಿ ಅಂತಹ ಮೆಮೊರಿ ನಡವಳಿಕೆಯು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ಅಲ್ಲಿ ವ್ಯವಸ್ಥೆಯ ವಿವಿಧ ಭಾಗಗಳ ನಡುವೆ ಸಂದೇಶ ರವಾನೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಕ್ಯೂಗಳನ್ನು ಆಗಾಗ್ಗೆ ಬಳಸಲಾಗುತ್ತದೆ. The ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸದಿದ್ದರೆ, ಅತಿಯಾದ ಮೆಮೊರಿ ಹಂಚಿಕೆಗಳು ಮತ್ತು ಆಳವಾದ ಪ್ರತಿಗಳು ಕಾರ್ಯಕ್ಷಮತೆ ಅನ್ನು ತೀವ್ರವಾಗಿ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ. ಸಿ ++ ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಮೆಮೊರಿಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ದಕ್ಷ, ಆಪ್ಟಿಮೈಸ್ಡ್ ಮತ್ತು ದೋಷ-ಮುಕ್ತ ಕೋಡ್ ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. 💡