极客教程如何创建和使用unique_ptr实例
C和C++编程语言中的实例是什么?
在C程序设计中，实例是一个对象或数据结构的一次出现。例如，如果你有一个名为“Dog”的类，你从这个类创建的每一条狗都将是“Dog”类的一个实例。这意味着每个类的实例将有自己的一组由类定义的数据和行为。
例如，你可以创建”Dog”类的两个实例，一个表示小狗”Fido”，另一个表示小狗”Snoopy “。这两个实例将各自有自己的一组特征，如它们的名字、年龄和品种，以及它们的行为，如吠叫或取球的能力。
在C语言中，可以像下面这样使用new关键字创建类的实例:
语法
Dog *fido = new Dog("Fido", 3, "Golden Retriever");
Dog *snoopy = new Dog("Snoopy", 5, "Beagle");
这里，我们创建了“Dog”类的两个实例，一个给Fido，另一个给Snoopy。每个实例都有它的数据集，比如它的名字、年龄和品种，在创建实例时指定。
下面的例子展示了如何用C语言创建一个名为“Dog”的类，然后创建这个类的实例。
代码:
// Define the Dog class
class Dog {
public:
// Constructor to initialize the instance
Dog(string name, int age, string breed) {
this->name = name;
this->age = age;
this->breed = breed;
}
// Method to make the dog bark
void bark() {
cout << this->name << " says: Woof! Woof!" << endl;
}
private:
// Private data members
string name;
int age;
string breed;
};
int main() {
// Create two instances of the Dog class
Dog *fido = new Dog("Fido", 3, "Golden Retriever");
Dog *snoopy = new Dog("Snoopy", 5, "Beagle");
// Make the dogs bark
fido->bark();
snoopy->bark();
return 0;
}
在这个例子中，“Dog”类有一个构造函数，用于初始化每个类实例的数据。它还有一个叫“bark”的方法，可以让狗叫。
在main函数中，我们创建了“Dog”类的两个实例，一个给Fido，另一个给Snoopy。然后我们在每个实例上调用bark方法，让狗汪汪叫。
运行这个程序时，它应该打印如下输出。
输出:
Fido says Woof! Woof!
Snoopy says Woof! Woof!
C++实例
在c++中，实例是对象或数据结构的一次出现。例如，如果你有一个名为“Dog”的类，那么你从这个类创建的每一条狗都将是这个“Dog”类的实例。这意味着每个类的实例将有自己的一组由类定义的数据和行为。
例如，你可以创建”Dog”类的两个实例，一个表示小狗”Fido”，另一个表示小狗”Snoopy “。这两个实例将各自有自己的一组特征，如它们的名字、年龄和品种，以及它们的行为，如吠叫或取球的能力。
在c++中，可以像下面这样使用new关键字创建类的实例:
Dog *fido = new Dog("Fido", 3, "Golden Retriever");
Dog *snoopy = new Dog("Snoopy", 5, "Beagle");
这里，我们创建了“Dog”类的两个实例，一个给Fido，另一个给Snoopy。每个实例都有它的数据集，比如它的名字、年龄和品种，在创建实例时指定。
代码:
// Define the Person's class
class Person {
public:
// Constructor to initialize the instance
Person(string name, int age, string gender) {
this->name = name;
this->age = age;
this->gender = gender;
}
// Method to print the person's name and age
void printInfo() {
cout << "Name: " << this->name << ", Age: " << this->age << ", Gender: " << this->gender << endl;
}
private:
// Private data members
string name;
int age;
string gender;
};
// the main driver code functionality starts from here
int main() {
// Create two instances of the Person class
Person *john = new Person("John", 32, "Male");
Person *jane = new Person("Jane", 28, "Female");
// Print the person's information
john->printInfo();
jane->printInfo();
// the main driver code functionality ens from here
return 0;
}
在这个例子中，Person类有一个构造函数，用于初始化每个类实例的数据。它还有一个“打印”方法，可以打印出person的姓名和年龄。
在main函数中，我们创建了”Person”类的两个实例，一个给John，另一个给Jane。然后，我们在每个实例上调用打印方法来打印它们的信息。
运行这个程序时，它应该打印如下输出。
输出:
Name: John, Age: 32, Gender: Male
Name: Jane, Age: 28, Gender: Female
指针到底是什么?
在C和c++中，指针是保存另一个变量的内存地址的变量。指针通常是指在运行时动态分配的内存位置，例如在C中使用malloc函数或在c++中使用new运算符时。
指针很有用，因为它们允许您直接操作为程序分配的内存，使您能够更好地控制程序如何使用内存。例如，你可以使用指针来访问和修改特定内存位置中的数据，或者创建比标准库提供的数据结构更高效和灵活的数据结构。
指针在其他语言中是不可用的，因为它们很难正确使用，并且会使代码更难理解和维护。例如，不正确地使用指针可能会导致内存泄漏或其他运行时错误，这可能很难诊断和修复。此外，指针会使推理代码的行为变得更加困难，因为指针的值可能在运行时动态改变。
然而，其他语言也提供了类似的功能，允许你直接操作内存，例如c++中的引用或c#中的“不安全”代码。这些功能在某些情况下可能是有用的，但应该谨慎使用，因为它们也可能引入指针可能导致的相同类型的问题。
C代码
#include
// The main driver code functionality starts from here
int main(void) {
int x = 10;
int *ptr = &x
printf("x = %d\n", x);
printf("ptr = %p\n", ptr);
printf("*ptr = %d\n", *ptr);
*ptr = 20;
printf("x = %d\n", x);
printf("ptr = %p\n", ptr);
printf("*ptr = %d\n", *ptr);
return 0;
// The main driver code functionality ends from here
}
输出:
x = 10
ptr = 0x7ffc1e1092ac
*ptr = 10
x = 20
ptr = 0x7ffc1e1092ac
*ptr = 20
C++代码
#include
// The main driver code functionality starts from here
int main(void) {
int x = 10;
int *ptr = &x
std::cout << "x = " << x << std::endl;
std::cout << "ptr = " << ptr << std::endl;
std::cout << "*ptr = " << *ptr << std::endl;
*ptr = 20;
std::cout << "x = " << x << std::endl;
std::cout << "ptr = " << ptr << std::endl;
std::cout << "*ptr = " << *ptr << std::endl;
return 0;
// The main driver functionality ends from here
}
输出:
x = 10
ptr = 0x7ffd1cfc1ebc
*ptr = 10
x = 20
ptr = 0x7ffd1cfc1ebc
*ptr = 20
在上面的例子中，ptr是一个指向int变量的指针。&操作符用于获取x变量的地址，*操作符用于获取x变量的地址操作符用于解引指针并访问存储在该地址的值。然后使用指针来修改x的值。
什么是智能指针?
在C和C++中，智能指针是一种类似于指针的对象，但具有帮助管理所指向对象的生命周期的附加特性。智能指针可以在不再需要对象时自动删除对象，并防止内存泄漏。
下面是c++中的一个智能指针的例子:
#include
#include
int main()
{
// Create a new integer and store its address in a smart pointer
std::unique_ptr ptr(new int(5));
// Access the integer value through the smart pointer
std::cout << *ptr << std::endl;
return 0;
}
输出:
5
说明:
这段代码将创建一个值为5的新整数对象，并将其地址存储在unique_ptr中。然后使用unique_ptr来访问整数的值，该值被打印到控制台。
因为unique_ptr管理它所指向的对象的生命周期，所以当unique_ptr在主函数结束时超出作用域时，integer对象将被自动删除。这有助于防止内存泄漏。
请注意，c++中有几种不同类型的智能指针，每种类型都有其特定的行为。unique_ptr只是其中一个例子。其他常见类型的智能指针包括shared_ptr和weak_ptr。
为什么C语言不支持智能指针?
智能指针是C++而不是C的特性。在C++中，智能指针是一种封装了原始指针的对象，它管理原始指针所指向的对象的生命周期。智能指针在超出作用域时，会自动删除所指向的对象，这有助于防止内存泄漏。
为什么unique_ptr在C编程语言中不可用?
unique_ptr不是C语言的一部分。unique_ptr是一种在c++编程语言中可用的智能指针类型。智能指针是一种对象，它的行为类似于普通指针，但也有额外的功能，如自动内存管理和边界检查。
Unique_ptr是一个智能指针，拥有并管理它所指向的对象。这意味着unique_ptr负责为它所指向的对象分配和释放内存，并且它是唯一可以访问或修改该内存的对象。unique_ptr提供了一种安全高效地管理动态分配内存的方法，在c++中它经常被用作原始指针的替代方案。
**C++中的Unique_ptr **
Std::unique_ptr是一个智能指针，可以管理动态分配内存的对象的生命周期。它确保当unique_ptr超出作用域时对象被正确删除，并提供了一种通过its ->和*来访问对象的方法操作符。
下面是一个如何创建和使用unique_ptr的示例。
示例1:
#include
#include
// The main driver code functionality starts from here
int main() {
// Create a unique_ptr that points to a new int with the value 5.
std::unique_ptr ptr1(new int(5));
// Use the -> and * operators to manipulate the object that the unique_ptr points to.
std::cout << *ptr1 << std::endl; // Outputs 5
*ptr1 = 6;
std::cout << *ptr1 << std::endl; // Outputs 6
// Transfer ownership of the object to a new unique_ptr.
std::unique_ptr ptr2 = std::move(ptr1);
// The original unique_ptr no longer points to the object.
std::cout << (ptr1 ? "true" : "false") << std::endl; // Outputs "false"
// The new unique_ptr now owns the object and can manipulate it.
std::cout << *ptr2 << std::endl; // Outputs 6
*ptr2 = 7;
std::cout << *ptr2 << std::endl; // Outputs 7
return 0;
// The main driver code functionality ends from here
}
输出:
5
6
false
6
7
说明:
在这个例子中，我们创建了一个名为ptr1的unique_ptr对象，它指向一个动态分配的值为5的int对象。我们使用->和*操作符来访问和操作ptr1所指向的对象。
接下来，我们使用std::move函数将对象的所有权转移给一个名为ptr2的新unique_ptr。这意味着ptr1不再指向对象。
示例2
#include
#include
// The main driver code functionality starts from here
int main() {
std::unique_ptr ptr(new int(10));
std::cout << "ptr = " << ptr.get() << std::endl;
std::cout << "*ptr = " << *ptr << std::endl;
*ptr = 20;
std::cout << "ptr = " << ptr.get() << std::endl;
std::cout << "*ptr = " << *ptr << std::endl;
return 0;
// The main driver code functionality ends from here
}
输出:
ptr = 0x55d09d214eb0
*ptr = 10
ptr = 0x55d09d214eb0
*ptr = 20
示例3
#include
#include // for std::unique_ptr
// A simple class with a constructor and a destructor
class MyClass
{
public:
MyClass() { std::cout << "MyClass constructed\n"; }
~MyClass() { std::cout << "MyClass destructed\n"; }
};
int main()
{
// Create a unique pointer to a MyClass object
std::unique_ptr ptr(new MyClass());
// ptr goes out of scope here, and the object pointed to by ptr
// is automatically deleted because of the unique_ptr
}
输出:
MyClass constructed
MyClass destructed