C++类和对象——（对象的赋值拷贝构造函数）

最新推荐文章于 2024-06-09 16:08:11 发布
最新推荐文章于 2024-06-09 16:08:11 发布
阅读量863 收藏 1
点赞数 2
分类专栏： C++stduy 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ttdffmm/article/details/131451645
版权

目录

对象的赋值

目录

对象的赋值

1、提出问题：

2、解决办法：

拷贝构造函数

1、拷贝构造函数的原型：

2、调用机制：

3、使用例程代码

总代码工程：

对象的赋值

1、提出问题：

能否使用一个已经构造好的对象去初始化另一个对象，C++编译器又是如何处理这些操作的呐。

类似于：

A a(10);
A b = a;

先来运行一下下边这一段程序：

#include <iostream>

using namespace std;

class Test
{
	public:
		int *sum;
		int x;
		int y;

	Test()
	{
		cout << "Test()" << endl;
		x = 0;
		y = 0;
		sum = new int[4];
	}

	Test(int a, int b):x(a), y(b)
	{
		cout << "Test(int a, int b)" << endl;
		sum = new int[4];
	}
};

int main()
{
	Test t1(10, 20); //Test t1 = (10, 20);
	t1.sum[0] = 1;
	t1.sum[1] = 2;
	t1.sum[2] = 3;
	t1.sum[3] = 4;
	Test t2 = t1;
	cout << t1.x << " " << t1.y << endl;
	cout << t2.x << " " << t2.y << endl;

	cout << t1.sum[2] << " " << t2.sum[2] << endl;
	cout << t1.sum << " " << t2.sum << endl;
	return 0;
}

打印结果如上图所示，对象t1和t2不止成员变量的值相同 ，地址也相同。也就是类似于两个对象名称共用一个内存空间。

这样的坏处是当只改变t2的成员变量值的时候相应t1的成员变量也会改变。

如果以下边一种写法：

#include <iostream>

using namespace std;

class Test
{
	public:
		int *sum;
		int x;
		int y;

	Test()
	{
		cout << "Test()" << endl;
		x = 0;
		y = 0;
		sum = new int[4];
	}

	Test(int a, int b):x(a), y(b)
	{
		cout << "Test(int a, int b)" << endl;
		sum = new int[4];
	}

	~Test()
	{
		cout << "~Test" << endl;
		delete[] sum;
	}
};

int main()
{
	//通过new操作符 构造对象（申请空间）
	Test *t1 = new Test(10, 20);

	t1->sum[0] = 10;
	t1->sum[1] = 20;
	t1->sum[2] = 30;
	t1->sum[3] = 40;
 
	Test *t2 = t1;

	cout << t2->sum[1] << endl;
	delete t1;
	cout << t2->sum[1] << endl;
	//cout << t1->sum << " " << t2->sum << endl;
	return 0;
}

发现：在执行delete t1语句前和执行后t2->sum[1]的值是不一样的，因为在t1->sum和t2->sum指向的是同一块内存空间当执行delete t1语句的时候会调用析构函数，在析构函数中之前申请的sum空间被释放了，所以s2->sum[1]的值就和原来的不一样了。

由上边两个问题得知：

用一个构造好的对象使用=可以构造一个新的对象，而且新的对象中的成员变量的值和构造好的对象中的成员变量的值是相等的（实现对象的拷贝）。但是这样做带来的危害是：如果两个类中有成员变量是指针类型（对于其他普通成员变量不会这样{第二种代码也会修改普通成员变量的值}），一旦其中一个对象被销毁调用析构函数将指针变量指向的堆空间进行了释放，另外一个对象所操作的指针所执行的堆空间是非法的！！（也就是后边要讲的浅拷贝）。

那我们想通过使用一个已经构造好的对象去初始化另一个对象而且对于指针类型成员变量不收影响该怎么办呐。

2、解决办法：

法子1：直接分开赋值

Test t1(10, 20); //Test t1 = (10, 20);
t1.sum[0] = 1;
t1.sum[1] = 2;
t1.sum[2] = 3;
t1.sum[3] = 4;

Test t2;
//普通成员变量的赋值
t2.x = t1.x;
t2.y = t1.y;
//指针类成员变量的赋值使用下面的memcpy函数
memcpy(t1.sum, t2.sum, 10*sizeof(int));

法子2：引出拷贝构造函数

依然使用“=”

原因：当我们使用“=”使用一个构造好的对象初始化一个新的对象的时候时，没有实现拷贝函数，编译器自动生成拷贝函数调用

拷贝构造函数

1、拷贝构造函数的原型：

类名(const 类名 &变量名);//此处变量名相当于一个形参的变量名。

2、调用机制：

使用一个构造好的对象初始化一个新的对象。

3、使用例程代码

如下：

#include <iostream>

using namespace std;

class Test
{
	public:
		int *sum;
		int x;
		int y;

	Test()
	{
		cout << "Test()" << endl;
		x = 0;
		y = 0;
		sum = new int[4];
	}

	Test(int a, int b):x(a), y(b)
	{
		cout << "Test(int a, int b)" << endl;
		sum = new int[4];
	}

	Test(const Test &t) //拷贝构造函数
	{
		cout << "Test(const Test &t)" << endl;
		//将t对象中的成员变量的值拷贝给新的对象
		x = t.x;
		y = t.y;
		sum = new int[4];//重新另给sum分配空间
		memcpy(sum, t.sum, 4*sizeof(int));//将数据拷贝过去
/*
        for(int i=0;i<4;i++)
            sum[i] = t.sum[i];//将数据拷贝过去
*/
	}

	~Test()
	{
		cout << "~Test" << endl;
		delete[] sum;
	}
};

int main()
{
	Test t1;
	t1.sum[0] = 1;
	t1.sum[1] = 2;
	t1.sum[2] = 3;
	t1.sum[3] = 4;

	Test t2 = t1;
	cout << t1.sum[2] << " " << t2.sum[2] << endl; // 3 3

	t1.sum[2] = 100;
	cout << t1.sum[2] << " " << t2.sum[2] << endl;// 100 3
	return 0;
}

注意：

1、拷贝构造函数当中：t 引用的是 = 右值  const:只读 防止t类内变量被修改（深拷贝）

拷贝构造函数为什么要这样写？

//-------引用作为函数的形参---------
//直接作为函数的形参
#if 0
void func2(Test t)//Test t = t1;触发拷贝构造函数的调用，而且func函数的调用并且函数结束t需要销毁
{

}
#endif
#if 1
void func2(const Test &t)
{

}
//等价与指针void func2(Test *t)
// 形参是个引用不会调用构造函数，
// 也不会引起中间对象（t）的产生和销毁,
// 使用const使其成为一个常量指针指向地址无法被修改
#endif

总代码工程：

/*
 * 《对象的析构》
 * 定义：在C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
 * 析构函数没有参数也没有任何返回对象‘
 * 析构函数在对象自动销毁的时候自动被调用
 * 析构函数调用机制<<C++编译器自动调用
 * */
#include <iostream>
using namespace std;
#if 0
class A
{
public:
//    char name[20];
//    int age;
    int a1;
    int a2;
    int a3;
    //假如类中成员变量为指针
    int *p;
    A()//无参数构造函数
    {
//        p=(int *)malloc(40);//在堆上生成一块空间(C中常用在堆上创建空间的方法)
        cout << "A()." << endl;
    }
    A(int a,int b,int c):a1(10),a2(20),a3(30)
    {
        cout << "A(" << a1 << a2 << a3 << " ):a1(10),a2(20),a3(30)." << endl;
        cout << "a="<< a << endl;
        cout << "b="<< b << endl;
        cout << "c="<< c << endl;
    }
    //析构函数
    ~A()
    {
        //在A对象销毁的时候，我们需要手动释放堆上的空间，放在析构函数当中
//        free(p);//（C中常用释放堆空间的方法）
        cout << "~A()" <<endl;
    }
};
//C++中对象的动态申请和释放
/*
 * new和delete的基本用法
 *
 * new 运算符动态分配堆内存
 * 使用形式：指针变量 = new类型（常量）；
 * eg:     int *p =new int(10);
 *explain：
 *         指针变量 = new类型[表达式]；
 * 作用：从堆上分配一块《类型》大小的存储空间
 * 其中：“常量”是初始化值，可缺省
 * 创建数组对象时，不能为对象指定初始值
 *
 * delete 运算符释放已分配的内存空间
 * 使用形式：delete 指针变量；
 *         delete[]指针变量；
 * 其中指针变量必须是一个new返回的指针
 *\
 * new与delete和malloc与free的区别：
 * 注意：new和delete是运算符，而不是函数，因此执行效率高。
 * 虽然为了与C语言兼容，C++仍保留malloc和free函数，
 * 但建议用户不用malloc和free函数，
 * 而用new和delete运算符。
 * new/delete 和 malloc/free有何取别呢？
 * 1、malloc/free为C的标准库函数，new、delete则为C++的操作运算符
 * 2、new能自动计算需要分配的内存空间，而malloc需要手工计算字节数
 * 3、new与delete直接带具体类型的指针，malloc和free返回void类型的指针。
 * 4、new类型是安全的，而malloc不是。例如int *p = new float[2];就会报错；
 * 而int *p = malloc(2 *sizeof(int))编译时编译器就无法指出错误来。
 * 5、new调用构造函数，malloc不能；delete调用析构函数，而free不能
 * 6、new/delete是操作符可以重载，malloc/free则不能
 * 总结：更安全，便利，能重载
 * */
//对象动态建立和释放
void Build_release(void)
{
    //在堆上申请一个int类型大小的空间（4Bytes）,并将申请的堆空间内容初始化为10
    int *p = new int(10);
    delete p;
//在堆上申请4个int类型大小的空间（4*sizeof(int)==16Bytes） 4：数组的长度
    int *p2 = new int[4];
    for (int i = 0; i < 4; i++)
    {
        cout << *(p2 + i) << endl; //cout << p2[i] << endl;
    }
    delete[] p2;
//在堆上申请一个Box类型大小的空间
    A *p3 = new A; //调用无参的构造函数
    delete p3;
//在堆上申请四个Box类型大小的空间
    A *p4 = new A[4]; //调用无参的构造函数
    delete[] p4;
//在堆上申请一个Box类型大小的空间
    A *p5 = new A(10, 10, 10); //调用带参数的构造函数
    delete p5;


}

int main() {
    Build_release();
    return 0;
}
#endif

/*
 * 使用已构造的对象初始化新的对象
 * 1、可以使用初始化好的对象，初始化另一个对象
 * */
#if 1
class Test
{
public:
    int *sum;
    int x;
    int y;

    Test()
    {
        cout << "Test()" << endl;
        x=0;
        y=0;
        sum = new int[4];
    }

    Test(int a,int b):x(a),y(b)
    {
        cout << "Test(int a,int b):x(a),y(b)" << endl;
        sum = new int[4];
    }

    //拷贝构造函数
    /*
     * 1、拷贝构造函数的原型
     * 类名（const 类名 &变量名）
     * 2、拷贝构造函数的调用时机：使用一个构造好的对象初始化一个新的对象
     * 深拷贝和浅拷贝的应用：当类的变量中含有指针类型的时候必须使用深拷贝，
     * */
    Test(const Test &t)//t 引用的是 右值  const:只读 防止t类内变量被修改（深拷贝）
    {
        cout << "Test(const Test &t)" << endl;
        x = t.x;
        y = t.y;
        sum = new int(4);//重新给sum分配空间
        for(int i=0;i<4;i++)
            sum[i] = t.sum[i];
        }

    //析构函数释放申请的空间
    ~Test()
    {
        cout << "~Test()" << endl;
        delete[] sum;
    }
};

//无构造函数
void func(void)
{
    Test *t1 = new Test(10,20);//调用构造函数：Test(int a,int b):x(a),y(b)

    t1->sum[0]=100;
    t1->sum[1]=101;
    t1->sum[2]=102;
    t1->sum[3]=103;

    Test t2 = *t1;//没有实现拷贝函数，编译器自动生成拷贝函数调用
    cout << t2.sum[0] <<endl;
    cout << t2.sum[1] <<endl;
    cout << t2.sum[2] <<endl;
    cout << t2.sum[3] <<endl;

    cout << "t2.x="<<t2.x<<endl;
    cout << "t2.y="<<t2.y<<endl;

    cout << "t1.sum="<<t1->sum<<endl;//两个对象的指针指向同一个内存空间
    cout << "t2.sum="<<t2.sum<<endl;

    //手动释放t1所指的申请的堆上的空间，意味着销毁 *t1这个对象，会自动调用析构函数
    //顺带手动释放成员变量sum所申请的空间
    delete t1;

    cout << t2.sum[0] <<endl;
    cout << t2.sum[1] <<endl;
    cout << t2.sum[2] <<endl;
    cout << t2.sum[3] <<endl;
    cout << "t2.sum="<<t2.sum<<endl;
    /*
     * 如果在类里边用一个对象给另一个对象赋值的时候如果一个对象为指针的话，那就回出问题
     * */
    //同一块堆空间将被释放两次会导致程序卡死
    //how to solve...
    //挨个赋值、
    // ==  /  memcpy(x,y,size);将y的值付给x空间大小为size
    //拷贝构造函数(自己实现)
    //

}

//有拷贝构造函数
void func1(void)
{
    Test t1(10,20);//调用构造函数：Test(int a,int b):x(a),y(b)
    t1.sum[0]=100;
    t1.sum[1]=101;
    t1.sum[2]=102;
    t1.sum[3]=103;
//使用已经构造好对象的t1 初始化一个对象
    Test t2 = t1;//调用拷贝构造函数 t2.Test(t1)
    cout << "t2.sum="<<t2.sum<<endl;
    cout << "t1.sum="<<t1.sum<<endl;//在拷贝构造函数当中重新给sum分配空间使

    for(int i = 0;i<4;i++)
        cout << t2.sum[i] << endl;

}

//-------引用作为函数的形参---------
//直接作为函数的形参
#if 0
void func2(Test t)//Test t = t1;触发拷贝构造函数的调用，而且func函数的调用并且函数结束t需要销毁
{

}
#endif
#if 1
void func2(const Test &t)
{

}
//等价与指针void func2(Test *t)
// 形参是个引用不会调用构造函数，
// 也不会引起中间对象（t）的产生和销毁,
// 使用const使其成为一个常量指针指向地址无法被修改
#endif

int main(){

    Test t1(10,20);//调用构造函数：Test(int a,int b):x(a),y(b)
    t1.sum[0]=100;
    t1.sum[1]=101;
    t1.sum[2]=102;
    t1.sum[3]=103;
/*
    //使用已经构造好的对象t1,初始化一个新的对象
    Test t2 = t1;
    cout << "t2.x="<<t2.x<<endl;
    cout << "t2.y="<<t2.y<<endl;

    cout << "t2.sum="<<t2.sum<<endl;
    cout << "t1.sum="<<t1.sum<<endl;//两个对象的指针指向同一个内存空间
    //注意：
*/

//    func();
//    cout << "func():No illness" << endl;


//    func1();
//    cout << "func1():Copied function" << endl;

    func2(t1);//现象调用拷贝构造函数



    return 0;
}
#endif

#if 0

#include <iostream>

using namespace std;

class Test
{
public:
    int *sum;
    int x;
    int y;

    Test()
    {
        cout << "Test()" << endl;
        x = 6;
        y = 0;
        sum = new int[4];
    }

    Test(int a, int b):x(a), y(b)
    {
        cout << "Test(int a, int b)" << endl;
        sum = new int[4];
    }
};

int main()
{
    Test t1(10, 20); //Test t1 = (10, 20);
    t1.sum[0] = 1;
    t1.sum[1] = 2;
    t1.sum[2] = 3;
    t1.sum[3] = 4;
    Test *t2 = &t1;
    cout << t1.x << " " << t2->x << endl;
    cout << t1.y << " " << t2->y << endl;

    cout << t1.sum[2] << " " << t2->sum[2] << endl;
    cout << t1.sum << " " << t2->sum << endl;
    t2->x=111;
    cout << t1.x << " " << t2->x << endl;

    return 0;
}

#endif

逸兴云飞~
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 拷贝赋值
weixin_53272394的博客
09-21 788
拷贝赋值函数 当存在的两个同类型的变量进行赋值操作时，会调用拷贝赋值函数 如果一个类没有实现拷贝赋值函数，则编译器会自动生成一个拷贝赋值函数，默认实现是浅拷贝赋值 如果需要实现深拷贝赋值，则需要手动实现 注意： 当类持有其它资源时，例如动态分配的内存、打开的文件、指向其他数据的指针、网络连接等，默认的赋值运算符就不能处理了，我们必须显式地重载它，这样才能将原有对象的所有数据都赋值给新对象。 拷贝赋值函数形如: class CLA_NAME{ //拷贝赋值函数 CLA_NAME& opera
C++——拷贝构造和重载的赋值运算符
01-20
在C++编程语言中，拷贝构造函数和重载的赋值运算符是两个非常重要的概念，它们都涉及到对象间的复制。这两个概念的理解和正确使用对于编写高效且无内存泄漏的代码至关重要。 **拷贝构造函数（Copy Constructor）** ...
C++对象赋值的四种方式
X-Teamer提炼商业万有引力模型, 低成本定制化开发
12-14 1万+
通过函数可以得到一个对象, 这个对象可以存在于堆中, 也可以存在于栈中, 总结下来一般有四种方式, 四种方式都可以实现目的, 但会带给我们不少陷阱. 做个简单总结.
【C++ | 拷贝赋值运算符函数】一文了解C++的 拷贝赋值运算符函数
最新发布
wkd_007的博客
06-09 1127
👉本文主要介绍了C++的拷贝赋值运算符，了解为什么需要拷贝赋值运算符，什么是拷贝赋值运算符，怎样声明、定义、使用拷贝赋值运算符，最后介绍默认的拷贝赋值运算符以及禁用赋值功能。
C++：类中的赋值函数
qinrenzhi的博客
12-10 1862
先来看一个例子： 1 #include&lt;iostream&gt; 2 #include&lt;string&gt; 3 using namespace std; 4 class Student{ 5 public: 6 Student(){ 7 cout&lt;&lt;"调用默认构造函数"&lt;&lt;endl; 8 }; 9 ...
c++对象的赋值
weixin_48617416的博客
04-08 1245
c++中是允许将对象的值赋给自己的。5 };a = a;编译器并不会阻止这种自我赋值的行为，在MyClass类中，因为只有一个int类型的数据成员，所以自我赋值并没有过多问题，但当类具有动态分配的内存或者其它资源时，必须将自我赋值考虑在内。所以为了阻止自我赋值的行为，我们需要做些检测，如果发现是自我赋值，那么立马返回。判断两个对象是否相同的方法之一是检查它们在内存中的位置是否相同，换句话说就是检查指向它们的指针是否相同。当一个非静态对象被创建时，指向对象数据的首地址是this指针。
C++ 对象间的赋值与拷贝构造函数
weixin_34090562的博客
07-27 220
1、对象间的赋值 /***A.h文件***/ #pragma once class A { public: int va; A(void); A(char* name); A(const A&amp; a); virtual void print(); char* name; void setVa(int va){...
CPP杂记——移动构造函数中需要注意的问题
01-08
在C++11之前，程序员通常会编写深拷贝构造函数来解决这个问题，但这对于临时对象来说是不必要的开销。C++11引入了右值引用，通过移动构造函数，可以直接转移临时对象的所有权，避免重复构造，提高性能。 2. **右值...
不要轻视拷贝构造函数与赋值函数
09-18
在C++编程中，拷贝构造函数和赋值函数是理解类的重要组成部分。虽然这两种构造函数通常由编译器自动提供，但它们对于确保数据安全性和类的行为正确性至关重要。本文将深入探讨拷贝构造函数与赋值函数的重要性，并...
NDK13_C++基础：构造函数、拷贝构造函数、浅拷贝与深拷贝.zip
03-26
C++中 这个语句执行完毕，在当前的堆内存内 初始化并且赋值好该对象 在java中执行这个语句，只是开辟了一块内存空间，并没初始化和赋值对象， 必须用new关键字，来进行初始化和赋值 ——————————————...
C++ 类与对象之日期类的创建代码解析
02-21
在这个例子中，拷贝构造函数通过传递一个`Date`类型的引用，将原始对象的年、月、日数据成员复制到新创建的对象中。 ##### 4. 析构函数 ```cpp ~Date() ``` 析构函数是在对象生命周期结束时自动调用的一个特殊成员...
C++的拷贝赋值函数
b1049112625的博客
01-20 2612
如果一个构造函数的第一个参数是自身类类型的引用，并且任何额外的参数都有默认值。则此构造函数就是拷贝构造函数参数必须是自身类类型的引用自身类类型好理解，为什么是引用？因为如果不是引用的话，在执行拷贝构造函数的时候，需要先对实参进行拷贝，此时执行的也是拷贝构造函数，这样就无限递归循环了，所以，必须是引用一般而言，拷贝构造函数的第一个参数是const类型为什么是const呢？首先拷贝构造函数的意思在于构造和拷贝，一般我们不需要改变原始的对象值。
【C++】类的拷贝赋值函数
梦想博客
02-27 3227
C++类的拷贝赋值函数使用及注意事项
C++类对象的复制与赋值
qq_20853741的博客
02-20 5969
本文主要介绍C++中类对象的赋值操作、复制操作，以及两者之间的区别，另外还会讲到“深拷贝”与“浅拷贝”的相关内容。 本系列内容会分为三篇文章进行讲解。 1 对象的赋值 1.1 what 如同基本类型的赋值语句一样，同一个类的对象之间也是可以进行赋值操作的，即将一个对象的值赋给另一个对象。 对于类对象的赋值，只会对类中的数据成员进行赋值，而不对成员函数赋值。 例如：obj1 和 obj2 是同一类 ClassA 的两个对象，那么对象赋值语句“obj2 = obj1;” 就会把对象 obj1 的数据
C++对象的赋值
weixin_75188368的博客
05-10 398
（1）对象的赋值只对其中的数据成员赋值，不对成员函数赋值。每个对象的数据成员占用独立的存储空间，不同对象的数据成员占有不同的存储空间，赋值的过程是将一个对象的数据成员在存储空间的值复制给另一个对象的数据成员的存储空间。同类的对象之间可以互相赋值，即一个对象的值可以赋值给另一个对象。默认就是把一个对象所有非static数据成员的值依次赋值给另一个对象。（2）类的数据成员中不能包括动态分配的数据，否则在赋值时可能出现意想不到的严重后果(这个问题在后面的运算符重载讲解)。●析构函数 (如果没有,会出现内存泄漏)
c++给对象赋值
一只菜猫的博客
09-21 1835
在c++中，只能给变量赋值，而不能给类型赋值，如： int = 5; //错误 int x; x=5 //正确 同样，不能给类赋值，而是先定义一个类对象，然后将值赋给改对象： Cat .itsAge = 5; //错误 Cat Firsty; Firsty.itsAge=5; //正确 如何访问类成员？ 定义一个世纪的Cat对象（如Firsty），就可以使用‘.’来访问该对象的成员。比如将50赋给Firsty的成员变量weight： Firsty.itsweight=50; 声明类： cl
C++中对象的赋值&&拷贝构造函数
qq_44423388的博客
11-10 2584
目录 1.对象与对象之间的赋值。 下面给出代码说明赋值语句 对象赋值的限制和特点 2.拷贝构造函数 拷贝构造函数的特点 自定义的拷贝构造函数的代码及运行结果 默认拷贝构造函数 调用拷贝构造函数的3种情况 结束！ 1.对象与对象之间的赋值。 同类型的对象之间可以进行赋值操作，即一个对象的值可以赋给另一个对象的。所指的对象的赋值是指对其中的数据成员赋值，而不是对成员函数赋值。 下面给出代码说明赋值语句 #include<iostream> usi...
C++类的赋值操作
weixin_53064820的博客
08-01 723
C++类的赋值操作
C++编程语言中类对象的赋值与复制介绍（一）
热门推荐
liitdar的博客
08-20 4万+
本系列文章主要介绍C++编程语言中类对象的赋值和复制操作，以及两者之间的区别，另外还会介绍“深拷贝”与“浅拷贝”的相关知识。本文为系列文章的第一篇，主要介绍C++编程语言中类对象的赋值的相关知识。
C++面向对象：拷贝构造函数详解
在面向对象的设计中，拷贝构造函数扮演了重要的角色，尤其是在处理复杂对象时，确保了新创建的对象是独立的，不会因为共享数据而导致意外的改变。例如，在处理包含动态分配内存的对象时，如果不正确地实现拷贝构造...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值