calloc与realloc和malloc的区别以及new
目录
calloc、realloc 和 malloc
三个函数的区别在于
更详细的示例代码
交叉使用
内存泄漏
悬空指针
内存重叠
new 的语法
使用 new 运算符在堆上创建学生对象的示例
new和malloc都可以用于在堆上分配内存
calloc、realloc 和 malloc
是 C/C++ 中用于动态内存分配的函数。
-
malloc 函数：malloc 函数用于在堆上分配指定大小的内存块。它接受一个参数，即所需内存块的字节数，返回一个指向分配内存的指针。如果分配失败，则返回 NULL。
-
calloc 函数：calloc 函数类似于 malloc 函数，但它还会将分配的内存块初始化为零。它接受两个参数，即所需内存块的个数和每个内存块的字节数。它返回一个指向分配内存的指针。如果分配失败，则返回 NULL。
-
realloc 函数：realloc 函数用于重新分配已分配内存的大小。它接受两个参数，即原始内存块的指针和新的内存块大小。如果内存分配成功，则返回一个指向新分配内存的指针。如果分配失败，则返回 NULL。同时，realloc 函数还会尝试保留原始内存块中的数据，将其复制到新分配的内存块中。
三个函数的区别在于
- malloc 只负责分配指定字节数的内存块，不对其进行初始化。
- calloc 在分配内存块的同时，将其初始化为零。
- realloc 用于重新分配内存块的大小，并尝试保留原始内存块中的数据。
注意：虽然这些函数在 C 中广泛使用，但在 C++ 中，推荐使用 new 和 delete 运算符进行动态内存分配和释放，以便与对象的构造函数和析构函数配合使用，更好地管理内存和资源。
当涉及到内存分配和重新分配时，以下是
更详细的示例代码
#include
#include
int main() {
// 例子1：使用 malloc 分配内存
int* ptr = (int*)malloc(5 * sizeof(int)); // 在堆上分配 5 个 int 类型大小的内存块
if (ptr == NULL) {
std::cout << "内存分配失败" << std::endl;
return 1;
}
// 例子2：使用 calloc 分配内存并初始化
int* ptr2 = (int*)calloc(5, sizeof(int)); // 在堆上分配 5 个 int 类型大小的内存块，并初始化为零
if (ptr2 == NULL) {
std::cout << "内存分配失败" << std::endl;
return 1;
}
// 例子3：使用 realloc 重新分配内存
int* ptr3 = (int*)realloc(ptr, 10 * sizeof(int)); // 将之前分配的内存块大小重新调整为 10 个 int 类型大小
if (ptr3 == NULL) {
std::cout << "内存分配失败" << std::endl;
free(ptr); // 释放之前分配的内存块
return 1;
}
// 释放内存
free(ptr);
free(ptr2);
free(ptr3);
return 0;
}
在这个例子中，我们首先使用 malloc 函数分配了一个包含 5 个 int 类型大小的内存块，并将其分配给 ptr 指针。然后，我们使用 calloc 函数分配了另一个包含 5 个 int 类型大小的内存块，并将其初始化为零，并将其分配给 ptr2 指针。最后，我们使用 realloc 函数重新分配了 ptr 指针指向的内存块的大小，将其调整为包含 10 个 int 类型大小，并将其分配给 ptr3 指针。
请注意，在使用这些函数进行内存分配之后，需要使用 free 函数释放已分配的内存，以避免内存泄漏。
交叉使用
malloc、calloc 和 realloc 函数时，可能会导致一些问题，如内存泄漏、悬空指针和内存重叠等。下面是这些问题的一些例子：
内存泄漏
如果在分配内存后没有正确释放它，就会导致内存泄漏。这意味着分配的内存将无法再被使用，并且会占用系统资源。例如，在下面的代码中，内存块 ptr 分配后没有被释放：
int* ptr = (int*)malloc(10 * sizeof(int));
// 使用分配的内存块进行操作
// 忘记释放内存块
悬空指针
悬空指针是指指向已释放或未分配内存的指针。当你尝试访问悬空指针时，可能会导致程序崩溃或产生未定义的行为。例如，在下面的代码中，内存块 ptr 被释放后，但指针没有被置为 NULL：
int* ptr = (int*)malloc(10 * sizeof(int));
free(ptr);
// ptr 是一个悬空指针
内存重叠
当你使用 realloc 函数重新分配内存时，如果新的内存块与原始内存块重叠，会导致未定义的行为。这种情况可能会破坏数据或导致程序崩溃。例如，在下面的代码中，当 realloc 函数将原始内存块扩展到更大的大小时，与之前分配的内存块可能发生重叠：
int* ptr = (int*)malloc(5 * sizeof(int));
int* ptr2 = (int*)realloc(ptr, 10 * sizeof(int)); // 内存重叠
为了避免这些问题，建议在使用 malloc、calloc 和 realloc 函数时注意以下几点：
- 确保在分配内存后及时调用
free函数释放内存。 - 在释放内存后将指针置为 NULL，以避免悬空指针。
- 在使用
realloc函数重新分配内存时，确保新的内存块与原始内存块没有重叠。
此外，C++ 中还提供了更安全和方便的动态内存分配和释放方式，推荐使用 new 和 delete 运算符进行管理动态内存。
C++ 中，new 运算符用于在动态存储区（堆）中分配指定大小的内存。
new 的语法
pointer = new type;
其中，type 指向要分配内存的类型，可以是基本类型、类类型或数组类型。pointer 是一个指针，它指向新分配的内存块的开头。
例如，下面是一个使用 new 运算符在堆上分配一个整数的示例：
int* ptr = new int;
在上面的示例中，new 运算符返回一个指向分配的内存块的指针，这个内存块的大小与 int 类型相同。我们将这个指针赋值给 ptr 变量，以便稍后可以使用它来访问这个内存块中的数据。
如果要在堆上分配一个数组，可以使用以下语法：
pointer = new type [number_of_elements];
其中，type 是数组元素的类型，number_of_elements 是数组元素的数量。
例如，下面是一个使用 new 运算符在堆上分配一个整数数组的示例：
int* ptr = new int[5];
在上面的示例中，new 运算符返回一个指向分配的内存块的指针，这个内存块的大小等于 5 * sizeof(int) 字节。我们将这个指针赋值给 ptr 变量，以便稍后可以使用它来访问这个内存块中的数据。
除了分配内存之外，new 运算符还可以调用构造函数来初始化新分配的内存。例如，下面是一个使用 new 运算符在堆上分配一个类的示例：
class MyClass {
public:
MyClass() {
std::cout << "MyClass 构造函数被调用" << std::endl;
}
};
MyClass* ptr = new MyClass;
在上面的示例中，new 运算符返回一个指向分配的 MyClass 类型内存块的指针，并调用 MyClass 类的默认构造函数进行初始化。我们将这个指针赋值给 ptr 变量，以便稍后可以使用它来访问这个内存块中的数据。
需要注意的是，使用 new 运算符分配的内存必须使用 delete 运算符进行释放。例如，上面的示例应该如下释放内存：
delete ptr;
如果分配的是数组，则应使用以下语法释放内存：
delete[] pointer;
例如，下面是一个使用 delete 运算符释放整数数组的示例：
delete[] ptr;
需要注意的是，如果不释放使用 new 运算符分配的内存，就会导致内存泄漏。在释放内存之后，最好将指针置为 NULL，以避免悬空指针的问题。
当你使用 new 运算符在堆上分配内存时，可以考虑使用类来演示。下面是一个
使用 new 运算符在堆上创建学生对象的示例
#include
#include
class Student {
public:
Student(const std::string& name, int age) : name(name), age(age) {
std::cout << "学生对象 " << name << " 被创建" << std::endl;
}
~Student() {
std::cout << "学生对象 " << name << " 被销毁" << std::endl;
}
void DisplayInfo() {
std::cout << "姓名：" << name << std::endl;
std::cout << "年龄：" << age << std::endl;
}
private:
std::string name;
int age;
};
int main() {
// 使用 new 运算符在堆上创建一个学生对象
Student* ptr = new Student("小明", 18);
// 调用对象的成员函数
ptr->DisplayInfo();
// 释放内存
delete ptr;
return 0;
}
在上面的示例中，我们定义了一个 Student 类，它有一个带有姓名和年龄参数的构造函数、一个析构函数和一个显示信息的成员函数。在 main 函数中，我们使用 new 运算符在堆上创建一个 Student 对象，并将返回的指针赋给 ptr 变量。然后，我们调用 ptr 指向的对象的成员函数来显示学生的信息。最后，我们使用 delete 运算符释放了分配的内存。
运行上述代码，输出结果如下：
学生对象 小明 被创建
姓名：小明
年龄：18
学生对象 小明 被销毁
这个示例演示了如何使用 new 和 delete 运算符来动态分配和释放对象的内存。记得在使用完毕后及时释放内存，以避免内存泄漏。
这段代码是一个简单的C++示例，演示了如何使用new运算符在堆上创建对象，并使用delete释放内存。
首先，代码定义了一个名为Student的类，表示学生对象。该类有两个私有成员变量：name（姓名）和age（年龄）。构造函数Student用于初始化对象的姓名和年龄，并在创建对象时打印一条消息。析构函数~Student在对象销毁时被调用，用于释放资源并打印一条销毁消息。成员函数DisplayInfo用于打印学生对象的姓名和年龄。
std::string是C++标准库中的一个类，用于表示字符串。它是C++中处理字符串的一种常用方式。
std::string类提供了各种成员函数和操作符，用于对字符串进行操作，包括字符串的连接、截取、查找、替换等。它还提供了许多便捷的方法，如获取字符串长度、判断字符串是否为空、将字符串转换为整数等。使用
std::string类可以方便地进行字符串的操作和处理，而不需要手动管理内存或处理字符数组。它也提供了一些与C风格字符串的兼容性函数，以便与现有的C代码进行交互。要在C++程序中使用
std::string，需要包含头文件，并使用std命名空间。例如：#include#include int main() { std::string str = "Hello, World!"; std::cout << str << std::endl; return 0; } 上述代码创建了一个名为
str的std::string对象，并将其初始化为"Hello, World!"。然后，通过std::cout输出该字符串到控制台。
std::string是C++中用于表示字符串的类，提供了丰富的字符串操作方法和功能。
在main函数中，使用new运算符在堆上动态地创建了一个Student对象，并将指向该对象的指针赋值给ptr变量。创建对象时，构造函数会被调用，并打印一条创建消息。
接下来，通过ptr指针调用了对象的成员函数DisplayInfo，以打印学生对象的姓名和年龄。
最后，在程序结束前，使用delete运算符释放了通过new分配的内存。释放内存时，析构函数会被调用，并打印一条销毁消息。
这样，该程序就完成了对堆上动态分配对象的创建、使用和销毁的过程。使用new和delete可以在堆上分配和释放内存，使得对象的生命周期可以由程序控制，更加灵活。
new和malloc都可以用于在堆上分配内存
但它们之间有以下几个区别：
-
new是C++的关键字，而malloc是C语言的库函数。因此，在C++中使用new更为方便和安全，而在C中则更常用malloc。 -
new会自动计算要分配的内存大小，并返回指向已分配内存的指针。而malloc需要手动计算内存大小，并返回一个void*类型的指针，需要进行类型转换后才能使用。这可能会导致一些潜在的错误。 -
new会调用类的构造函数来初始化对象，而malloc只是简单地分配一块内存。因此，使用new可以确保对象被正确地初始化，而使用malloc需要手动调用构造函数。 -
new会抛出异常，而malloc只会返回NULL。在内存分配失败时，new会抛出std::bad_alloc异常，而malloc则会返回NULL指针。因此，在使用new时需要考虑异常处理，而在使用malloc时需要检查返回值是否为NULL。
虽然new和malloc都可以用于在堆上分配内存，但由于new更方便、更安全，而且可以自动初始化对象，因此在C++中更常用new。不过，对于一些特殊的内存分配场景，如需要对齐或不需要初始化等情况下，可能需要使用malloc。