M

MLOG

ಕನ್ನಡ

ದೃಢವಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗಾಗಿ ಆಧುನಿಕ C++ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು (unique_ptr, shared_ptr, weak_ptr) ಅನ್ವೇಷಿಸಿ. ಇದು ಮೆಮೊರಿ ಸೋರಿಕೆಗಳನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಿರತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

C++ ಆಧುನಿಕ ವೈಶಿಷ್ಟ್ಯಗಳು: ದಕ್ಷ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗಾಗಿ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

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

ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳ ಅಗತ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳ ನಿರ್ದಿಷ್ಟತೆಗಳ ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳುವ ಮೊದಲು, ಅವುಗಳು ಎದುರಿಸುವ ಸವಾಲುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಕ್ಲಾಸಿಕ್ C++ ನಲ್ಲಿ, ಡೆವಲಪರ್‌ಗಳು new ಮತ್ತು delete ಬಳಸಿಕೊಂಡು ಕೈಯಾರೆ ಮೆಮೊರಿಯನ್ನು ಹಂಚಿಕೆ ಮತ್ತು ಡೀಅಲೋಕೇಶನ್ ಮಾಡಲು ಜವಾಬ್ದಾರರಾಗಿರುತ್ತಾರೆ. ಈ ಕೈಪಿಡಿ ನಿರ್ವಹಣೆಯು ದೋಷಪೂರಿತವಾಗಿದೆ, ಇದು ಈ ಕೆಳಗಿನವುಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ:

ಈ ಸಮಸ್ಯೆಗಳು ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್‌ಗಳು, ಊಹಿಸಲಾಗದ ನಡವಳಿಕೆ ಮತ್ತು ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು ಡೈನಾಮಿಕ್ ಆಗಿ ಹಂಚಿಕೆಯಾದ ವಸ್ತುಗಳ ಜೀವಿತಾವಧಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುವ ಮೂಲಕ ಸೊಗಸಾದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಸಂಪನ್ಮೂಲ ಸ್ವಾಧೀನವು ಪ್ರಾರಂಭವಾಗಿದೆ (RAII) ತತ್ವವನ್ನು ಅನುಸರಿಸುತ್ತವೆ.

RAII ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು: ಶಕ್ತಿಯುತ ಸಂಯೋಜನೆ

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

C++ ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳ ವಿಧಗಳು

C++ ಮೂರು ಮುಖ್ಯ ರೀತಿಯ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ವಿಶಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಹೊಂದಿದೆ:

std::unique_ptr: ವಿಶೇಷ ಮಾಲೀಕತ್ವ

std::unique_ptr ಡೈನಾಮಿಕ್ ಆಗಿ ಹಂಚಿಕೆಯಾದ ವಸ್ತುವಿನ ವಿಶೇಷ ಮಾಲೀಕತ್ವವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಒಂದೇ unique_ptr ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿಗೆ ಸೂಚಿಸಬಹುದು. unique_ptr ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿರುವಾಗ, ಅದು ನಿರ್ವಹಿಸುವ ವಸ್ತುವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳಿಸಲಾಗುತ್ತದೆ. ಇದು ಏಕೈಕ ಘಟಕವು ವಸ್ತುವಿನ ಜೀವಿತಾವಧಿಗೆ ಜವಾಬ್ದಾರರಾಗಿರಬೇಕಾದ ಸನ್ನಿವೇಶಗಳಿಗೆ unique_ptr ಅನ್ನು ಆದರ್ಶಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: std::unique_ptr ಅನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "MyClass ನಿರ್ಮಿಸಿದ್ದು ಮೌಲ್ಯದೊಂದಿಗೆ: " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass ನಾಶವಾಯಿತು ಮೌಲ್ಯದೊಂದಿಗೆ: " << value_ << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    std::unique_ptr<MyClass> ptr(new MyClass(10)); // ಒಂದು unique_ptr ಅನ್ನು ರಚಿಸಿ

    if (ptr) { // ಪಾಯಿಂಟರ್ ಮಾನ್ಯವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
        std::cout << "ಮೌಲ್ಯ: " << ptr->getValue() << std::endl;
    }

    // ptr ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿರುವಾಗ, MyClass ವಸ್ತುವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳಿಸಲಾಗುತ್ತದೆ
    return 0;
}

std::unique_ptr ನ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳು:

ಉದಾಹರಣೆ: std::unique_ptr ನೊಂದಿಗೆ std::move ಅನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(42));
    std::unique_ptr<int> ptr2 = std::move(ptr1); // ಮಾಲೀಕತ್ವವನ್ನು ptr2 ಗೆ ವರ್ಗಾಯಿಸಿ

    if (ptr1) {
        std::cout << "ptr1 ಇನ್ನೂ ಮಾನ್ಯವಾಗಿದೆ" << std::endl; // ಇದು ಕಾರ್ಯಗತವಾಗುವುದಿಲ್ಲ
    } else {
        std::cout << "ptr1 ಈಗ ಶೂನ್ಯವಾಗಿದೆ" << std::endl; // ಇದು ಕಾರ್ಯಗತವಾಗುತ್ತದೆ
    }

    if (ptr2) {
        std::cout << "ptr2 ಸೂಚಿಸುವ ಮೌಲ್ಯ: " << *ptr2 << std::endl; // ಔಟ್‌ಪುಟ್: ptr2 ಸೂಚಿಸುವ ಮೌಲ್ಯ: 42
    }

    return 0;
}

ಉದಾಹರಣೆ: std::unique_ptr ನೊಂದಿಗೆ ಕಸ್ಟಮ್ ಡಿಲೀಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

// ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ಡಿಲೀಟರ್
struct FileDeleter {
    void operator()(FILE* file) const {
        if (file) {
            fclose(file);
            std::cout << "ಫೈಲ್ ಅನ್ನು ಮುಚ್ಚಲಾಗಿದೆ." << std::endl;
        }
    }
};

int main() {
    // ಫೈಲ್ ತೆರೆಯಿರಿ
    FILE* file = fopen("example.txt", "w");
    if (!file) {
        std::cerr << "ಫೈಲ್ ತೆರೆಯುವಲ್ಲಿ ದೋಷ." << std::endl;
        return 1;
    }

    // ಕಸ್ಟಮ್ ಡಿಲೀಟರ್‌ನೊಂದಿಗೆ ಒಂದು unique_ptr ಅನ್ನು ರಚಿಸಿ
    std::unique_ptr<FILE, FileDeleter> filePtr(file);

    // ಫೈಲ್‌ಗೆ ಬರೆಯಿರಿ (ಐಚ್ಛಿಕ)
    fprintf(filePtr.get(), "ನಮಸ್ಕಾರ ಪ್ರಪಂಚ!
");

    // filePtr ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿರುವಾಗ, ಫೈಲ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮುಚ್ಚಲಾಗುತ್ತದೆ
    return 0;
}

std::shared_ptr: ಹಂಚಿದ ಮಾಲೀಕತ್ವ

std::shared_ptr ಡೈನಾಮಿಕ್ ಆಗಿ ಹಂಚಿಕೆಯಾದ ವಸ್ತುವಿನ ಹಂಚಿದ ಮಾಲೀಕತ್ವವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಅನೇಕ shared_ptr ನಿದರ್ಶನಗಳು ಒಂದೇ ವಸ್ತುವಿಗೆ ಸೂಚಿಸಬಹುದು ಮತ್ತು ಕೊನೆಯ shared_ptr ಇದಕ್ಕೆ ಸೂಚಿಸುವಾಗ ಮಾತ್ರ ವಸ್ತುವನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ. ಪ್ರತಿ shared_ptr ಅನ್ನು ರಚಿಸಿದಾಗ ಅಥವಾ ನಕಲಿಸಿದಾಗ ಮತ್ತು ಅದನ್ನು ನಾಶಪಡಿಸಿದಾಗ ಕೌಂಟ್ ಅನ್ನು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: std::shared_ptr ಅನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1(new int(100));
    std::cout << "ಉಲ್ಲೇಖ ಎಣಿಕೆ: " << ptr1.use_count() << std::endl; // ಔಟ್‌ಪುಟ್: ಉಲ್ಲೇಖ ಎಣಿಕೆ: 1

    std::shared_ptr<int> ptr2 = ptr1; // shared_ptr ಅನ್ನು ನಕಲಿಸಿ
    std::cout << "ಉಲ್ಲೇಖ ಎಣಿಕೆ: " << ptr1.use_count() << std::endl; // ಔಟ್‌ಪುಟ್: ಉಲ್ಲೇಖ ಎಣಿಕೆ: 2
    std::cout << "ಉಲ್ಲೇಖ ಎಣಿಕೆ: " << ptr2.use_count() << std::endl; // ಔಟ್‌ಪುಟ್: ಉಲ್ಲೇಖ ಎಣಿಕೆ: 2

    {
        std::shared_ptr<int> ptr3 = ptr1; // ಒಂದು ವ್ಯಾಪ್ತಿಯಲ್ಲಿ shared_ptr ಅನ್ನು ನಕಲಿಸಿ
        std::cout << "ಉಲ್ಲೇಖ ಎಣಿಕೆ: " << ptr1.use_count() << std::endl; // ಔಟ್‌ಪುಟ್: ಉಲ್ಲೇಖ ಎಣಿಕೆ: 3
    } // ptr3 ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿದೆ, ಉಲ್ಲೇಖ ಎಣಿಕೆ ಕಡಿಮೆಯಾಗುತ್ತದೆ

    std::cout << "ಉಲ್ಲೇಖ ಎಣಿಕೆ: " << ptr1.use_count() << std::endl; // ಔಟ್‌ಪುಟ್: ಉಲ್ಲೇಖ ಎಣಿಕೆ: 2

    ptr1.reset(); // ಮಾಲೀಕತ್ವವನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿ
    std::cout << "ಉಲ್ಲೇಖ ಎಣಿಕೆ: " << ptr2.use_count() << std::endl; // ಔಟ್‌ಪುಟ್: ಉಲ್ಲೇಖ ಎಣಿಕೆ: 1

    ptr2.reset(); // ಮಾಲೀಕತ್ವವನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿ, ಈಗ ವಸ್ತುವನ್ನು ಅಳಿಸಲಾಗಿದೆ

    return 0;
}

std::shared_ptr ನ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳು:

std::shared_ptr ಗಾಗಿ ಮುಖ್ಯ ಪರಿಗಣನೆಗಳು:

std::weak_ptr: ಸ್ವಾಮ್ಯವಿಲ್ಲದ ವೀಕ್ಷಕ

std::weak_ptr shared_ptr ನಿಂದ ನಿರ್ವಹಿಸಲ್ಪಡುವ ವಸ್ತುವಿಗೆ ಸ್ವಾಮ್ಯವಿಲ್ಲದ ಉಲ್ಲೇಖವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಉಲ್ಲೇಖ ಎಣಿಕೆ ಕಾರ್ಯವಿಧಾನದಲ್ಲಿ ಭಾಗವಹಿಸುವುದಿಲ್ಲ, ಅಂದರೆ ಎಲ್ಲಾ shared_ptr ನಿದರ್ಶನಗಳು ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿರುವಾಗ ವಸ್ತುವನ್ನು ಅಳಿಸದಂತೆ ಇದು ತಡೆಯುವುದಿಲ್ಲ. ಸ್ವಾಮ್ಯವಿಲ್ಲದೆ ವಸ್ತುವನ್ನು ವೀಕ್ಷಿಸಲು weak_ptr ಉಪಯುಕ್ತವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಗಳನ್ನು ಮುರಿಯಲು.

ಉದಾಹರಣೆ: ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಗಳನ್ನು ಮುರಿಯಲು std::weak_ptr ಅನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> b;
    ~A() { std::cout << "A ನಾಶವಾಯಿತು" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> a; // ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಯನ್ನು ತಪ್ಪಿಸಲು weak_ptr ಅನ್ನು ಬಳಸುವುದು
    ~B() { std::cout << "B ನಾಶವಾಯಿತು" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b = b;
    b->a = a;

    // weak_ptr ಇಲ್ಲದಿದ್ದರೆ, A ಮತ್ತು B ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಯ ಕಾರಣದಿಂದಾಗಿ ಎಂದಿಗೂ ನಾಶವಾಗುವುದಿಲ್ಲ
    return 0;
} // A ಮತ್ತು B ಸರಿಯಾಗಿ ನಾಶವಾಗುತ್ತವೆ

ಉದಾಹರಣೆ: ವಸ್ತು ಮಾನ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು std::weak_ptr ಅನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(123);
    std::weak_ptr<int> weakPtr = sharedPtr;

    // ವಸ್ತು ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
    if (auto observedPtr = weakPtr.lock()) { // lock() ವಸ್ತುವಿದ್ದರೆ shared_ptr ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
        std::cout << "ವಸ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ: " << *observedPtr << std::endl; // ಔಟ್‌ಪುಟ್: ವಸ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ: 123
    }

    sharedPtr.reset(); // ಮಾಲೀಕತ್ವವನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿ

    // sharedPtr ಅನ್ನು ಮರುಹೊಂದಿಸಿದ ನಂತರ ಮತ್ತೆ ಪರಿಶೀಲಿಸಿ
    if (auto observedPtr = weakPtr.lock()) {
        std::cout << "ವಸ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ: " << *observedPtr << std::endl; // ಇದು ಕಾರ್ಯಗತವಾಗುವುದಿಲ್ಲ
    } else {
        std::cout << "ವಸ್ತುವನ್ನು ನಾಶಪಡಿಸಲಾಗಿದೆ." << std::endl; // ಔಟ್‌ಪುಟ್: ವಸ್ತುವನ್ನು ನಾಶಪಡಿಸಲಾಗಿದೆ.
    }

    return 0;
}

std::weak_ptr ನ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳು:

ಸರಿಯಾದ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಆರಿಸುವುದು

ನೀವು ಜಾರಿಗೊಳಿಸಬೇಕಾದ ಮಾಲೀಕತ್ವದ ಸೆಮ್ಯಾಂಟಿಕ್ಸ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಸರಿಯಾದ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು:

ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳ ಪ್ರಯೋಜನಗಳನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಲು ಮತ್ತು ಸಾಮಾನ್ಯ ನ್ಯೂನತೆಗಳನ್ನು ತಪ್ಪಿಸಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ:

ಉದಾಹರಣೆ: std::make_unique ಮತ್ತು std::make_shared ಅನ್ನು ಬಳಸುವುದು


#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "MyClass ನಿರ್ಮಿಸಿದ್ದು ಮೌಲ್ಯದೊಂದಿಗೆ: " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass ನಾಶವಾಯಿತು ಮೌಲ್ಯದೊಂದಿಗೆ: " << value_ << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    // std::make_unique ಬಳಸಿ
    std::unique_ptr<MyClass> uniquePtr = std::make_unique<MyClass>(50);
    std::cout << "ವಿಶಿಷ್ಟ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯ: " << uniquePtr->getValue() << std::endl;

    // std::make_shared ಬಳಸಿ
    std::shared_ptr<MyClass> sharedPtr = std::make_shared<MyClass>(100);
    std::cout << "ಹಂಚಿದ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯ: " << sharedPtr->getValue() << std::endl;

    return 0;
}

ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ವಿನಾಯಿತಿ ಸುರಕ್ಷತೆ

ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು ವಿನಾಯಿತಿ ಸುರಕ್ಷತೆಗೆ ಗಮನಾರ್ಹವಾಗಿ ಕೊಡುಗೆ ನೀಡುತ್ತವೆ. ಡೈನಾಮಿಕ್ ಆಗಿ ಹಂಚಿಕೆಯಾದ ವಸ್ತುಗಳ ಜೀವಿತಾವಧಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುವ ಮೂಲಕ, ವಿನಾಯಿತಿ ಎಸೆದರೂ ಸಹ ಮೆಮೊರಿಯನ್ನು ಡೀಅಲೋಕೇಟ್ ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಮೆಮೊರಿ ಸೋರಿಕೆಗಳನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸಮಗ್ರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಕಚ್ಚಾ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ಸಂಭಾವ್ಯವಾಗಿ ಸೋರಿಕೆಯಾಗುವ ಮೆಮೊರಿಯ ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:


#include <iostream>

void processData() {
    int* data = new int[100]; // ಮೆಮೊರಿಯನ್ನು ಹಂಚಿಕೆ ಮಾಡಿ

    // ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ ಅದು ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಬಹುದು
    try {
        // ... ಸಂಭಾವ್ಯವಾಗಿ ವಿನಾಯಿತಿ-ಎಸೆಯುವ ಕೋಡ್ ...
        throw std::runtime_error("ಏನೋ ತಪ್ಪಾಗಿದೆ!"); // ಉದಾಹರಣೆ ವಿನಾಯಿತಿ
    } catch (...) {
        delete[] data; // ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಮೆಮೊರಿಯನ್ನು ಡೀಅಲೋಕೇಟ್ ಮಾಡಿ
        throw; // ವಿನಾಯಿತಿಯನ್ನು ಮತ್ತೆ ಎಸೆಯಿರಿ
    }

    delete[] data; // ಮೆಮೊರಿಯನ್ನು ಡೀಅಲೋಕೇಟ್ ಮಾಡಿ (ಯಾವುದೇ ವಿನಾಯಿತಿ ಎಸೆಯದಿದ್ದರೆ ಮಾತ್ರ ತಲುಪುತ್ತದೆ)
}

ಮೊದಲ delete[] data; ಹೇಳಿಕೆಯ ಮೊದಲು try ಬ್ಲಾಕ್‌ನಲ್ಲಿ ವಿನಾಯಿತಿ ಎಸೆದರೆ, data ಗಾಗಿ ಹಂಚಿಕೆಯಾದ ಮೆಮೊರಿ ಸೋರಿಕೆಯಾಗುತ್ತದೆ. ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ಇದನ್ನು ತಪ್ಪಿಸಬಹುದು:


#include <iostream>
#include <memory>

void processData() {
    std::unique_ptr<int[]> data(new int[100]); // ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್ ಬಳಸಿ ಮೆಮೊರಿಯನ್ನು ಹಂಚಿಕೆ ಮಾಡಿ

    // ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ ಅದು ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಬಹುದು
    try {
        // ... ಸಂಭಾವ್ಯವಾಗಿ ವಿನಾಯಿತಿ-ಎಸೆಯುವ ಕೋಡ್ ...
        throw std::runtime_error("ಏನೋ ತಪ್ಪಾಗಿದೆ!"); // ಉದಾಹರಣೆ ವಿನಾಯಿತಿ
    } catch (...) {
        throw; // ವಿನಾಯಿತಿಯನ್ನು ಮತ್ತೆ ಎಸೆಯಿರಿ
    }

    // ಡೇಟಾವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಅಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ; unique_ptr ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ
}

ಈ ಸುಧಾರಿತ ಉದಾಹರಣೆಯಲ್ಲಿ, unique_ptr ಸ್ವಯಂಚಾಲಿತವಾಗಿ data ಗಾಗಿ ಹಂಚಿಕೆಯಾದ ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ವಿನಾಯಿತಿ ಎಸೆದರೆ, ಸ್ಟಾಕ್ ತೆರೆದುಕೊಳ್ಳುತ್ತಿದ್ದಂತೆ unique_ptr ನ ಡೀಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ, ವಿನಾಯಿತಿಯನ್ನು ಹಿಡಿಯಲಾಗಿದೆಯೇ ಅಥವಾ ಮತ್ತೆ ಎಸೆಯಲಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ ಮೆಮೊರಿಯನ್ನು ಡೀಅಲೋಕೇಟ್ ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

ಸುರಕ್ಷಿತ, ಸಮರ್ಥ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ C++ ಕೋಡ್ ಬರೆಯಲು ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು ಮೂಲಭೂತ ಸಾಧನಗಳಾಗಿವೆ. ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಮೂಲಕ ಮತ್ತು RAII ತತ್ವವನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ಅವು ಕಚ್ಚಾ ಪಾಯಿಂಟರ್‌ಗಳೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಸಾಮಾನ್ಯ ನ್ಯೂನತೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತವೆ ಮತ್ತು ಹೆಚ್ಚು ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತವೆ. ವಿಭಿನ್ನ ರೀತಿಯ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಸೂಕ್ತ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಪ್ರತಿ C++ ಡೆವಲಪರ್‌ಗೆ ಅತ್ಯಗತ್ಯ. ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು, ಡೇಂಗ್ಲಿಂಗ್ ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ಇತರ ಮೆಮೊರಿ ಸಂಬಂಧಿತ ದೋಷಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು, ಇದು ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಸುರಕ್ಷಿತ ಸಾಫ್ಟ್‌ವೇರ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

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

ಹೆಚ್ಚಿನ ಕಲಿಕೆ