ਕਸਟਮ struct ਾਂਚਿਆਂ ਦੇ ਨਾਲ C ++ ਕਤਾਰਾਂ ਵਿੱਚ ਮੈਮੋਰੀ ਲੀਕ ਨੂੰ ਰੋਕਣਾ

C ++ ਕਤਾਰਾਂ ਵਿੱਚ ਮੈਮੋਰੀ ਵਿਵਹਾਰ ਨੂੰ ਸਮਝਣਾ

C ++ ਵਿਚ ਮੈਮੋਰੀ ਮੈਨੇਜਮੈਂਟ ਇਕ ਮਹੱਤਵਪੂਰਣ ਵਿਸ਼ਾ ਹੈ, ਖ਼ਾਸਕਰ ਜਦੋਂ ਗਤੀਸ਼ੀਲ ਅਲਾਟਮੈਂਟਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ. ਇਕ ਆਮ ਮੁੱਦਾ ਜਿਸ ਨੂੰ ਡਿਵੈਲਪਰਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਹੈ ਮੈਮੋਰੀ ਲੀਕ , ਜੋ ਕਿ ਜਦੋਂ ਅਲੋਕਡ ਮੈਮੋਰੀ ਸਹੀ ਤਰ੍ਹਾਂ ਠੰ .ਤ ਨਹੀਂ ਹੁੰਦੀ. 🚀

ਇਸ ਦ੍ਰਿਸ਼ ਵਿਚ, ਅਸੀਂ ਕਸਟਮ struct ਾਂਚੇ (ਮੈਸੇਜ`) ਵਿਚ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ ਜਿਸ ਵਿਚ ਆਰਜੀ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਚਰਿੱਤਰ ਐਰੇ ਸ਼ਾਮਲ ਹਨ. ਫਿਰ ਇਸ struct ਾਂਚਾ ਫਿਰ ਇੱਕ `std ਵਿੱਚ ਧੱਕਿਆ ਜਾਂਦਾ ਹੈ :: ਕਤਾਰ, ਇੱਕ ਕਾੱਪੀ ਕੰਸਟਰਕਟਰ . ਹਾਲਾਂਕਿ ,`mmove () `,`, ਮੈਮੋਰੀ ਐਡਰੈੱਸ ਉਮੀਦਾਂ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ.

ਬਹੁਤ ਸਾਰੇ C ++ ਡਿਵੈਲਪਰਾਂ ਦਾ ਸਮਾਨ ਮੁੱਦਿਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਖ਼ਾਸਕਰ ਜਦੋਂ ਪੁਆਇੰਟਰ ਅਤੇ ap ੇਰ ਮੈਮੋਰੀ . ਗ਼ਲਤ ਪੱਤਰ ਡੰਗਲਿੰਗ ਪੁਆਇੰਟਰ, ਮੈਮੋਰੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ, ਜਾਂ ਇੱਥੋਂ ਤਕ ਕਿ ਪ੍ਰੋਗਰਾਮ ਕਰੈਸ਼ ਵੀ ਹੋ ਸਕਦੇ ਹਨ . ਇਸ ਤਰ੍ਹਾਂ, ਇਹ ਸਮਝੋ ਕਿ ਮੈਮੋਰੀ ਨੂੰ ਕਿਉਂ ਖਿੱਚਣਾ ਮਜ਼ਬੂਤ ​​ਅਤੇ ਕੁਸ਼ਲ ਕੋਡ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ.

ਇਹ ਲੇਖ ਇਹ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ ਕਿ ਮੈਮੋਰੀ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਤਬਦੀਲੀ ਕਿਵੇਂ ਬਦਲਦੀ ਹੈ ਅਤੇ ਅਸੀਂ ਮੈਮੋਰੀ ਲੀਕ ਨੂੰ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹਾਂ ਗਤੀਸ਼ੀਲ ਅਲਾਟਡ ਐਰੇ ਨਾਲ ਕਤਾਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ. ਅਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਤੋੜ ਦੇਵਾਂਗੇ, Is ਵਿੱਚ ਇਨਸਾਈਟਸ ਪ੍ਰਦਾਨ ਕਰਾਂਗੇ ਸਹੀ ਕਾੱਪੀ ਸੈਮੈਂਟਿਕਸ , ਅਤੇ C ++ ਵਿੱਚ ਮੈਮੋਰੀ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ. 💡

C ++ ਕਤਾਰਾਂ ਵਿੱਚ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਡੂੰਘੀ ਗੋਤਾਖੋਰੀ

ਪਹਿਲਾਂ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਗਈਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ, ਅਸੀਂ C ++ ਵਿਚ ਇਕ ਆਮ ਮੁੱਦੇ ਨਾਲ ਨਜਿੱਠਿਆ: ਮੈਮੋਰੀ ਲੀਕ ਅਤੇ ਗਲਤ ਮੈਮੋਰੀ ਮੈਨੇਜਮੈਂਟ ਕਤਾਰਾਂ . ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਮੈਨੂਅਲ ਅਲਾਟਮੈਂਟ ਅਤੇ ਡੈਮਲੋਕੇਸ਼ਨ ਨੂੰ ਹੱਥੀਂ ਸੰਭਾਲਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਦੂਜਾ ਸਮਾਰਟ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ. ਦੋਵੇਂ ਬੇਵਕੂਫ਼ ਮੈਮੋਰੀ ਲੀਕ ਨੂੰ ਰੋਕਣ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਨ ਅਤੇ ਸਹੀ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ. 🚀

ਇੱਥੇ ਮੁੱਖ ਮੁੱਦਾ ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਆਬਜੈਕਟ ਨੂੰ ਇੱਕ `std :: ਕਤਾਰ ਵਿੱਚ ਧੱਕਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਕਾੱਪੀ ਜਾਂ ਮੂਵ ਓਪਰੇਸ਼ਨ . ਜੇ ਅਸੀਂ ਇੱਕ ਸਹੀ ਦੀ ਨਕਲ ਕਰਨ ਅਤੇ ਅਸਾਈਨਮੈਂਟ ਓਪਰੇਟਰ , ਡਿਫਾਲਟ ope ਲੌਇ ਕਾੱਪੀ ਨੂੰ ਉਸੇ ਹੀ ਮੈਮੋਰੀ ਦਾ ਹਵਾਲਾ ਦੇ ਸਕਦੀਆਂ ਹਨ, ਜੋ ਕਿ ਪੁਆਇੰਟਰ ਜਾਂ ਅਚਾਨਕ ਵਿਵਹਾਰ ਕਰਦੇ ਹਨ. ਡੂੰਘੀਆਂ ਕਾਪੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ , ਜਿਵੇਂ ਸਾਡੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਕਿ ਹਰੇਕ ਇਕਾਈ ਦੀ ਆਪਣੀ ਯਾਦਦਾਸ਼ਤ ਦੀ ਵੰਡ ਹੁੰਦੀ ਹੈ, ਬੇਲੋੜੀ ਮਾੜੇ ਪ੍ਰਭਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ.

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਸੁਧਾਰ std :: ਵਿਲੱਖਣ_ਪਟਰ` , ਜੋ ਆਬਜੈਕਟ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ ਨਿਕਲਦਾ ਹੈ ਤਾਂ ਮੈਮੋਰੀ ਨੂੰ ਖਤਮ ਕਰ ਦਿੰਦਾ ਹੈ. ਇਹ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ [ਕਾਲਾਂ ਨੂੰ ਮਿਟਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਰੋਕਦਾ ਹੈ ਅਤੇ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਮੈਮੋਰੀ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਸਤੇਮਾਲ ਕਰਕੇ `std :: ਮੇਕ_ਨਿਕ`, ਸਾਨੂੰ * ਅਪਵਾਦ ਸੁਰੱਖਿਆ , ਅਲਾਟਮੈਂਟ ਅਸਫਲ ਹੋਣ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਲੀਕ ਕਰਨ ਤੋਂ ਰੋਕਣਾ. ਇਸ ਸੰਕਲਪ ਦੀ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਜੀਵਨ ਉਦਾਹਰਣ ਇਹ ਹੈ ਕਿ ਗੇਮ ਇੰਜਾਈਨ ਟੈਕਸਟ ਡੇਟਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ , ਜਦੋਂ ਹੁਣ ਕੋਈ ਜ਼ਰੂਰਤ ਨਹੀਂ ਸੀ. 🎮

ਕੁਲ ਮਿਲਾ ਕੇ, ਦੋਵੇਂ ਪਹੁੰਚ ਸਮੱਸਿਆ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ .ੰਗ ਨਾਲ ਹੱਲ ਕਰਦੇ ਹਨ, ਪਰ ਸਮਾਰਟ ਪੁਆਇੰਟਰ ਪਹੁੰਚ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ ਹੈ ਇਸਦੀ ਸੁਰੱਖਿਆ ਦੇ ਕਾਰਨ. ਜੇ ਤੁਸੀਂ ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਅਰਜ਼ੀ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੋ *, ਜਿਵੇਂ ਕਿ ਰੀਅਲ-ਟਾਈਮ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਜਾਂ ਏਮਬੈਡਡ ਸਿਸਟਮ, ਸੀ ++ ਵਿਚ ਮਾਸਟਰਿੰਗ ਮੈਨੇਜਮੈਂਟ ਜ਼ਰੂਰੀ ਹੈ. ਇਹ ਸਮਝਣ ਕਿ ਆਬਜੈਕਟਸ ਵਿੱਚ ਕਿਵੇਂ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਤਾਰਾਂ ਵਿੱਚ ਕਿਵੇਂ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ, ਡਿਵੈਲਪਰ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੇ ਹਨ, ਮਜਬੂਤ, ਲੀਕ-ਮੁਫਤ ਕੋਡ ਲਿਖ ਸਕਦੇ ਹਨ. 💡

#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 ++ ਕਤਾਰਾਂ ਵਿੱਚ ਮੈਮੋਰੀ ਐਡਰੈੱਸ ਬਦਲਾਅ ਨੂੰ ਸਮਝਣਾ

ਜਦੋਂ c ++ ਕਤਾਰਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ ਤਾਂ ਅਤੇ ਆਰਜੀ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਮੈਮੋਰੀ, ਇਕ ਅਚਾਨਕ ਵਿਹਾਰ ਤਬਦੀਲੀ ਤਬਦੀਲੀ ਤਬਦੀਲੀ ਤਬਦੀਲੀ ਤਬਦੀਲੀ ਹੈ ਮੈਮੋਰੀ ਐਡਰੈੱਸ ਵਿਚ ਤਬਦੀਲੀ ਤਬਦੀਲੀ ਕਰੋ ਮੈਮੋਰੀ ਐਡਰੈੱਸ ਵਿਚ ਤਬਦੀਲੀ ਤਬਦੀਲੀ ਕਰੋ ਜਦੋਂ ਕਿ ਕਤਾਰ ਵਿਚ ਆਬਜ੍ਰੀ ਨੂੰ ਧੱਕਾ ਕਰੋ. ਇਹ ਵਾਪਰਦਾ ਹੈ ਕਿਉਂਕਿ ਕਤਾਰ ਕਾਪੀਆਂ ਦੇ ਹਵਾਲਿਆਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਬਜਾਏ ਆਬਜੈਕਟਸ ਦੀਆਂ * ਤਿਆਰ ਕਰਦਾ ਹੈ. ਹਰ ਵਾਰ ਇਕ ਆਬਜੈਕਟ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਕ ਨਵੀਂ ਮੈਮੋਰੀ ਵੰਡ ਆਰਜੀ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਮੈਂਬਰਾਂ ਲਈ, ਵੱਖ ਵੱਖ ਮੈਮੋਰੀ ਪਤੇ ਹੁੰਦੇ ਹਨ.

ਸਾਡੀ ਉਦਾਹਰਣ ਵਿਚ ਇਕ ਮੁੱਖ ਮਸਲਾ ਇਹ ਹੈ ਕਿ ਚਾਰ ਐਰੇ (`ਡੇਟਾ`) ap ੇਰ 'ਤੇ ਅਲਾਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ ਜਦੋਂ ਇਕਾਈ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਸਲ ਅਤੇ ਕਾਪੀ ਇਕੋ ਮੈਮੋਰੀ ਦੀ ਜਗ੍ਹਾ ਨੂੰ ਸਾਂਝਾ ਨਾ ਕਰੋ. ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਜਦੋਂ ਅਸੀਂ ਆਬਜੈਕਟ ਨੂੰ ਕਤਾਰ ਵਿੱਚ ਦਬਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਧੱਕਦੇ ਸਮੇਂ ਦਾ ਪਤਾ ਛਾਪਦੇ ਹਾਂ, ਤਾਂ ਮੁੱਲ ਵੱਖੋ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ. ਇਸ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਮੂਵ ਸੈਮੈਂਟਿਕਸ ਨਾਲ ਦੇ ਨਾਲ :: ਮੂਵ () `, ਜੋ ਕਿ ਡਾਟਾ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਬਜਾਏ ਮਾਲਕੀਅਤ ਨੂੰ ਤਬਦੀਲ ਕਰਦਾ ਹੈ. ਇਕ ਹੋਰ ਪਹੁੰਚ ਸਮਾਰਟ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ ਐਸਟੀਡੀ :: ਸ਼ੇਅਰਡ_ਪਟਰ` ਜਾਂ `std :: ਵਿਲੱਖਣ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ.

ਅਸਲ-ਸੰਸਾਰ ਦੀਆਂ ਅਰਜ਼ੀਆਂ ਵਿੱਚ, ਅਜਿਹੇ ਮੈਮੋਰੀਕਿੰਗ ਜਾਂ ਰੀਅਲ-ਟਾਈਮ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ , ਜਿੱਥੇ ਕਿ ਕਤਾਰਾਂ ਸਿਸਟਮ ਦੇ ਵੱਖ ਵੱਖ ਹਿੱਸਿਆਂ ਵਿੱਚ ਲੰਘਣ ਵਾਲੇ ਸੰਦੇਸ਼ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਅਕਸਰ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ. 🚀 ਜੇ ਸਹੀ ਤਰ੍ਹਾਂ ਪ੍ਰਬੰਧਿਤ ਨਹੀਂ, ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਵੰਡ ਅਤੇ ਡੂੰਘੀ ਕਾਪੀਆਂ ਸਹੀ ਤਰ੍ਹਾਂ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦੀਆਂ ਹਨ ਪ੍ਰਦਰਸ਼ਨ . ਇਹ ਸਮਝਣ ਕਿ ਸੀ ++ ਹੁੱਡ ਦੇ ਅਧੀਨ ਮੈਮੋਰੀ ਦਾ ਕਿਵੇਂ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਡਿਵੈਲਪਰਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕੁਸ਼ਲ, ਅਨੁਕੂਲਿਤ ਅਤੇ ਬੱਗ-ਮੁਕਤ ਕੋਡ. 💡