C++ C++；，施工人员的原因

我有两个问题

1） 构造函数真正做什么？如果在声明实例时不使用构造函数会发生什么

2） 你能告诉我这两者的区别吗

A a(1,2)

A *a = new A(1,2)

---

致以最诚挚的问候。

构造函数是一个与类同名的函数。构造函数的主要用途是将新创建对象的成员变量初始化为一些默认值。它还可能调用其他初始化函数。
就像C++中的其他函数一样，构造函数也可以重载。（重载函数是具有不同参数的现有函数的新版本）。例如，考虑以下三个构造函数：<代码>点< /代码>类：

class Point
{
public:
    Point() : x_(0), y_(0) { }
    Point(int x, int y) : x_(x), y_(y) { }
    Point(const Point& p) : x_(p.x), y_(p.y) { }
private:
    int x_;
    int y_;
};

第一个构造函数将坐标初始化为零，而第二个构造函数允许用户指定其默认值：

void create_and_destroy_points ()
{
   Point p1; // => x_ = 0, y_ = 0
   Point p2(100, 200); // x_ = 100, y_ = 200
}

当以这种方式声明时，这些

点

对象将在堆栈上分配。这意味着分配给它们的内存将在

create\u和\u destroy\u points

函数返回时自动释放。换句话说，

p1

和

p2

在功能之外没有任何用处。
还可以在堆上分配对象。这将在运行时分配对象，然后它们可以在各种函数调用中生存。它们被分配了

new

关键字，并继续生存，直到它们被解除分配

delete

。如果在使用堆分配的对象后未能删除该对象，将导致内存泄漏

第三个构造函数是复制构造函数。当通过复制另一个对象来构造新对象时，将调用该函数：

Point p1;
Point p2 = p1; // calls the copy constructor for p2 with p1 as argument.
Point p3(p1);  // alternate syntax

---

构造函数初始化类的成员变量，以便它可以使用。声明实例时不使用构造函数的结果因上下文而异

如果在堆上分配变量，如下所示：

A *a;

a

将指向内存中的随机地址，直到将其分配给NULL或0，或一个类的现有或新实例，例如：

A *a = new A(1, 2);

如果要在堆栈上分配变量，将使用以下语法：

A a(1, 2); // if parameters are used
A a; // if no parameters are used

上述两种方法都调用类

A

的构造函数，在堆栈上分配它的一个实例。因此，这回答了你的两个问题-第一个示例在堆栈上分配了

A

的一个实例，第二个示例在堆上分配了

A

的一个实例。

为了回答#2，第一个示例在堆栈上分配了类型为A的变量'A'，而您的第二个指针为类型a分配了一个指针“*a”。该指针有一个起始值，一个指向动态内存的地址。在这两种情况下，都会使用2个参数调用：：A（）构造函数

1） 构造函数真正做什么

对象的构造由两部分组成：

分配所需的内存量

在构造函数中执行代码

如果我们不使用 在声明 实例

构造函数总是被执行的，即使您没有显式地调用它们。例如：

std::string a;

A a1;    // uses first constructor, i.e. A::A() 
A a2();  // also uses first constructor

A* a3 = new A(1, 2); // uses second constructor, i.e. A::A(int a, int b) 
A a4(1, 2);          // also uses second constructor

void fn() {
    A a(1, 2);
    ...
    ...
}

A* fn()
{
    A *a = new A(1,2)
    return a;
}

这里将调用string类的默认构造函数

2） 你能告诉我区别吗 在这两者之间

A a(1,2)

A *a = new A(1,2)

此代码调用用户定义的构造函数

A a;

此代码调用默认构造函数。

1）构造函数应仅用于成员变量初始化

A a;

class A {
public:
    A() { a = 0; b = 0; }
    A(int a, int b) { this->a = a; this->b = b; }

private:
    int a;
    int b;
};

在上面的类中，我们有两个构造函数，每个构造函数初始化成员变量，一个使用零，另一个使用给定的参数

类可以有任意数量的构造函数。创建类实例时，必须始终调用其中一个实例，例如：

std::string a;

A a1;    // uses first constructor, i.e. A::A() 
A a2();  // also uses first constructor

A* a3 = new A(1, 2); // uses second constructor, i.e. A::A(int a, int b) 
A a4(1, 2);          // also uses second constructor

void fn() {
    A a(1, 2);
    ...
    ...
}

A* fn()
{
    A *a = new A(1,2)
    return a;
}

2） 声明：

A a(1, 2)

声明一个变量，该变量保存绑定到作用域的实例，这意味着当程序退出该作用域时，该实例将被自动删除。例如：

std::string a;

A a1;    // uses first constructor, i.e. A::A() 
A a2();  // also uses first constructor

A* a3 = new A(1, 2); // uses second constructor, i.e. A::A(int a, int b) 
A a4(1, 2);          // also uses second constructor

void fn() {
    A a(1, 2);
    ...
    ...
}

A* fn()
{
    A *a = new A(1,2)
    return a;
}

在函数请求时，将构造一个实例，当我们退出该函数时，该实例将被自动删除

在下列情况下：

A *a = new A(1,2)

变量a已声明，它指向新创建的a实例。您必须手动删除某个实例上的“delete a”，但您的实例可以在声明a的范围内继续存在。例如：

std::string a;

A a1;    // uses first constructor, i.e. A::A() 
A a2();  // also uses first constructor

A* a3 = new A(1, 2); // uses second constructor, i.e. A::A(int a, int b) 
A a4(1, 2);          // also uses second constructor

void fn() {
    A a(1, 2);
    ...
    ...
}

A* fn()
{
    A *a = new A(1,2)
    return a;
}

在这里，函数fn返回在其主体内创建的实例，即实例在函数范围内生存。

可能的重复