写一篇关于对象变量生命周期的文章，大纲大致为： 1. C++ 类构造函数 & 析构函数，对应new delete 的用法 2. C语言中的 堆中栈中创建和销毁的几种方法 3. 智能指针的在管理对象生命周期中用法 4. 单例类如何管理对象生命中期 5. 容器在对象变量生命周期应用场景。列举对应的示例。

对象变量生命周期管理是编程中非常重要的一个方面。在程序中，我们需要确保对象在需要使用时能够被正确地分配内存，并在不再需要时能够被释放。本文将会介绍一些常见的对象变量生命周期管理技术。

1. C++ 类构造函数 & 析构函数，对应new delete 的用法

在C++中，我们可以使用new关键字来动态地分配内存，并返回一个指向新分配的内存的指针。这个指针可以被赋给一个指针变量，这个变量被称为对象指针。当我们不再需要这个对象时，我们需要使用delete关键字来释放这个对象所占用的内存。在类的构造函数中，我们可以使用new关键字来分配内存，并在析构函数中使用delete关键字来释放内存。

例如，在以下的代码中，我们定义了一个名为Person的类，包含一个字符串类型的成员变量name。在构造函数中，我们使用new关键字来为这个字符串分配内存。在析构函数中，我们使用delete关键字来释放这个内存。

#include <iostream>
#include <string>

class Person{
public:
    Person(const std::string& name): name(new std::string(name)){
        std::cout << "Person is created." << std::endl;
    }
    ~Person(){
        delete name;
        std::cout << "Person is destroyed." << std::endl;
    }
private:
    std::string* name;
};

int main(){
    Person* person = new Person("Alice");
    delete person;
    return 0;
}

2. C语言中的 堆中栈中创建和销毁的几种方法

在C语言中，我们可以使用malloc()函数来在堆中动态地分配内存。我们可以使用free()函数来释放这些内存。在栈中创建的变量，在函数结束时就会被自动销毁。

例如，在以下的代码中，我们使用malloc()函数来分配一个大小为10的整型数组。在使用完之后，我们使用free()函数来释放这个内存。

#include <stdio.h>
#include <stdlib.h>

int main(){
    int* arr = (int*)malloc(10 * sizeof(int));
    free(arr);
    return 0;
}

3.智能指针的在管理对象生命周期中用法

智能指针是一种特殊的指针，它可以自动地管理对象的生命周期。它可以自动地在对象不再被使用时释放内存。智能指针有多种类型，包括shared_ptr、unique_ptr和weak_ptr。每种类型都有其优缺点。shared_ptr可以被多个指针共享，但是可能会导致循环引用。unique_ptr只能被一个指针拥有，但是可以避免循环引用。weak_ptr可以解决循环引用问题，但是不能直接访问对象。

例如，在以下的代码中，我们使用unique_ptr模板类来管理一个整型数组的生命周期。在unique_ptr对象被销毁时，数组所占用的内存会自动地被释放。

#include <iostream>
#include <memory>

int main(){
    std::unique_ptr<int[]> arr(new int[10]);
    return 0;
}

4. 单例类如何管理对象生命中期

单例类是一种特殊的类，它只能被实例化一次。在单例类中，我们可以使用静态成员变量来保存单例对象的指针。在类的构造函数中，我们可以使用new关键字来分配内存，并将指针赋给静态成员变量。在析构函数中，我们可以使用delete关键字来释放内存。

例如，在以下的代码中，我们定义了一个名为Singleton的单例类。在构造函数中，我们使用new关键字来分配内存。在析构函数中，我们使用delete关键字来释放内存。我们还定义了一个静态成员变量instance来保存单例对象的指针。

#include <iostream>

class Singleton{
public:
    static Singleton& getInstance(){
        static Singleton instance;
        return instance;
    }
    ~Singleton(){
        std::cout << "Singleton is destroyed." << std::endl;
    }
private:
    Singleton(){
        std::cout << "Singleton is created." << std::endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
};

int main(){
    Singleton& singleton = Singleton::getInstance();
    return 0;
}

5. 容器在对象变量生命周期应用场景

容器是一种可以存储多个对象的数据结构。在容器中，我们可以使用智能指针来管理对象的生命周期。容器可以帮助我们管理对象的分配和释放，避免内存泄漏和野指针。在使用容器时，我们需要注意容器的生命周期，确保对象在容器中存储的时间不会超过其生命周期。

例如，在以下的代码中，我们定义了一个名为Person的类。在main函数中，我们使用std::vector容器来存储多个Person对象的指针。在程序结束时，容器会自动地销毁所有对象，并释放内存。

#include <iostream>
#include <vector>
#include <memory>

class Person{
public:
    Person(const std::string& name): name(name){ }
    void sayHello(){
        std::cout << "Hello, my name is " << name << "." << std::endl;
    }
private:
    std::string name;
};

int main(){
    std::vector<std::unique_ptr<Person>> persons;
    persons.push_back(std::unique_ptr<Person>(new Person("Alice")));
    persons.push_back(std::unique_ptr<Person>(new Person("Bob")));
    for(auto& person: persons){
        person->sayHello();
    }
    return 0;
}

总之，对象变量生命周期管理是编程中非常重要的一个方面。我们需要选择合适的技术来管理对象的生命周期，以确保程序的正确性和健壮性。以上介绍的技术只是其中的几种，我们还可以根据具体的需求选择其他技术。