精华内容
下载资源
问答
  • //析构函数:没有参数也没有任何返回类型,被自动调用 #include<iostream> using namespace std; class Test { public: Test();//构造函数 ~Test();//析构函数:先创建的对象后释放 void print...

    1.c++编译器会自动调用构造函数

    //构造函数(与类名相同)
    //析构函数:没有参数也没有任何返回类型,被自动调用
    #include<iostream>
    using namespace std;
    class Test
    {
    public:
    	Test();//无参构造函数
    	~Test();//析构函数:先创建的对象后释放
    	void print()
    	{
    		cout << a << endl;
    		cout << p << endl;
    	}
    private:
    	int a;
    	char *p;
    };
    
    Test::Test()//完成对属性的初始化工作
    {
    	a = 10;
    	p = (char*)malloc(sizeof(100));
    	strcpy(p, "Rita");
    	cout<< "我是构造函数" << endl;
    }
    
    Test::~Test()
    {
    	if (p != NULL)
    	{
    		free(p);
    	}
    	cout << "我是析构函数,我被调用了" << endl;
    }
    //给对象搭建一个平台,研究对象的行为
    void objplay()
    {
    	//先创建的对象后释放
    	Test t1;
    	t1.print();
    	printf("分隔符\n");
    	Test t2;
    	t2.print();
    }
    int main()
    {
    	objplay();
    	system("pause");
    	return 0;
    }

    分析:先调用t1的无参构造函数,再调用print(),再调用t2的无参构造函数,再调用print(),最后先调用t2的析构函数,因为分配的内存在栈里,先入栈的后出栈,所以先定义的后释放,后调用析构函数。

    2.拷贝构造函数的调用(三种方法)

    #include<iostream>
    using namespace std;
    //类的构造函数的分类:无参构造函数。有参构造函数。拷贝构造函数
    class Test2
    {
    public:
    	Test2()//无参构造函数
    	{
    		m_a = 0;
    		m_b = 0;
    		cout << "无参构造函数" << endl;
    	}
    	Test2(int a)
    	{
    		m_a = a;
    		m_b = 0;
    	}
    	Test2(int a, int b)
    	{
    		m_a = a; m_b = b;
    		cout << "有参构造函数"<< endl;
    	}
    	//copy构造函数
    	Test2(const Test2& obj)
    	{
    		cout << "我也是构造函数"<< endl;
    	}
    public:
    	void print()
    	{
    		cout << "普通成员函数"<< endl;
    	}
    private:
    	int m_a;
    	char m_b;
    };
    
    int main04()//调用无参构造函数
    {
    	Test2 t1;
    	system("pause");
    	return 0;
    }
    int main()//调用有参构造函数
    {
    	//1.括号法
    	Test2 t1(1, 2);//调用参数构造函数,c++编译器自动调用
    	t1.print();
    	//2.=号法
    	Test2 t2 = (1, 2, 3, 4, 5);//= c++对等号符功能增强,c++编译器自动的调用构造函数
    	Test2 t3 = 5;
    	//3.直接调用构造函数,手动的调用构造函数
    	Test2 t4 = Test2(1, 2);//匿名对象的去和留,后面会说
    	t1 = t4;//赋值操作:把t4copy给t1,对象的初始化和对象的赋值是两个不同的概念
    
    	system("pause");
    	return 0;
    }

    3.拷贝构造函数的调用

    #include<iostream>
    using namespace std;
    //构造函数的调用
    class Test4
    {
    public:
    	Test4()//无参构造函数
    	{
    		m_a = 0;
    		m_b = 0;
    		cout << "无参构造函数" << endl;
    	}
    	Test4(int a)
    	{
    		m_a = a; m_b = 0;
    	}
    	Test4(int a, int b)
    	{
    		m_a = a; m_b = b;
    		cout << "有参构造函数" << endl;
    	}
    	//copy构造函数
    	Test4(const Test4& obj)
    	{
    		cout << "我也是构造函数" << endl;
    		m_a = obj.m_a + 100;//虽然是拷贝构造函数,也不是完全拷贝,可以根据自己的意愿拷贝(+100)
    		m_b = obj.m_b + 100;
    	}
    public:
    	void print()
    	{
    		cout << "普通成员函数" << endl;
    		cout << m_a << m_b << endl;
    	}
    private:
    	int m_a;
    	int m_b;
    };
    
    int main06()
    {
    	Test4 t1(1, 2);
    	Test4 t0(1, 2);
    	t0 = t1;//不会调用拷贝构造函数
    	//第一种调用方法
    	Test4 t2 = t1;//用t1初始化t2,此时会调用拷贝构造函数
    	t2.print();
    
    	system("pause");
    	return 0;
    }
    //第二种调用时机
    int main()
    {
    	Test4 t1(1, 2);
    	Test4 t0(1, 2);
    	Test4 t2(t1);// t1初始化t2,此时会调用拷贝构造函数
    	t2.print();
    
    	system("pause");
    	return 0;
    }

    4.形参是一个元素,b实参去初始化形参p,会调用copy构造函数

    #include<iostream>
    using namespace std;
    class Location
    {
    public:
    	Location(int xx = 0,int yy=0)
    	{
    		X = xx;
    		Y = yy;
    		cout << "Constructor Object\n" << endl;
    	}
    	//copy构造函数完成对象的初始化
    	Location(const Location& obj)
    	{
    		X = obj.X;
    		Y = obj.Y;
    	}
    	~Location()
    	{
    		cout << "Destroyed\n" << endl;
    	}
    	int getX()
    	{
    		return X;
    	}
    	int getY()
    	{
    		return Y;
    	}
    private:
    	int X;
    	int Y;
    };
    //形参是一个元素(不是指针也不是引用),当调用此函数时,c++编译器会自动调用copy构造函数,用实参初始化形参
    void f(Location p)
    {
    	cout << p.getX() << endl;
    }
    void playobj()
    {
    	Location a(1, 2);
    	Location b = a;
    	cout << "对象初始化完毕" << endl;
    	f(b);
    }
    int main()
    {
    	playobj();
    	system("pause");
    	return 0;
    }

    5.关于匿名对象的去和留(匿名对象是否会被析构)

    #include<iostream>
    using namespace std;
    class Location
    {
    public:
    	Location(int xx = 0, int yy = 0)
    	{
    		X = xx;
    		Y = yy;
    		cout << "Constructor Object\n" << endl;
    	}
    	//copy构造函数完成对象的初始化
    	Location(const Location& obj)
    	{
    		X = obj.X;
    		Y = obj.Y;
    	}
    	~Location()
    	{
    		cout << "Destroyed\n" << endl;
    	}
    	int getX()
    	{
    		return X;
    	}
    	int getY()
    	{
    		return Y;
    	}
    private:
    	int X;
    	int Y;
    };
    //g()函数 返回一个元素
    //结论1.函数的返回值是一个元素(复杂数据类型),返回的是一个新的匿名对象
    //如果用匿名对象初始化另一个同类型对象,匿名对象转化成有名对象,不会被析构
    //如果匿名对象赋值给另一个同类型对象,匿名对象被析构
    Location g()
    {
    	Location A(1, 2);
    	return A;//返回一个新的对象,没有名字
    }
    void objPlay1()
    {
    	g();
    }
    void objPlay2()
    {
    	//用匿名对象初始化m,此时c++编译器直接把匿名对象扶正,不会被析构
    	Location m = g();
    	cout << m.getX() << endl;
    }
    void objPlay3()
    {
    	//用匿名对象赋值给m2之后,匿名对象被析构
    	Location m2(1, 2);
    	m2 = g();//这不是初始化,这是赋值
    	cout << m2.getX() << endl;
    }
    int main()
    {
    	//objPlay1();//运行结果1.Constructor Object2.Destroyed3.Destroyed
    	//objPlay2();//运行结果1.Constructor Object2.Destroyed(析构A)3. 1  4.Destroyed(析构m)
    	objPlay3();//运行结果1.Constructor Object(创建m2)2.Constructor Object(创建A)3.Destroyed(析构A)4.Destroyed(析构匿名对象)5.  1   6..Destroyed(析构m2)
    	system("pause");
    	return 0;
    }




    展开全文
  • 初遇C++拷贝构造函数~

    2020-02-26 12:35:55
    拷贝构造函数作用:用一个已存在的对象来初始化一个正在创建...拷贝构造函数无任何函数返回类型说明; 若类声明中无拷贝构造函数,系统会自动给出一个默认的拷贝构造函数,该拷贝构造函数只进行对象数据成员间的对位...

    拷贝构造函数作用:用一个已存在的对象来初始化一个正在创建的新对象。拷贝构造函数有以下特征:

    1. 拷贝构造函数名与类名相同,形参只有一个,是对象的引用,所以不能重载拷贝构造函数,拷贝构造函数原形为:<类名>(<类名>&对象名);
    2. 拷贝构造函数无任何函数返回类型说明;
    3. 若类声明中无拷贝构造函数,系统会自动给出一个默认的拷贝构造函数,该拷贝构造函数只进行对象数据成员间的对位拷贝,即所谓的“浅拷贝”;
    4. 某些情况下,用户必须在类定义中给出一个显示的拷贝构造函数,以实现用户指定的用一个对象初始化另一个对象的功能,即所谓的“深拷贝”;
    5. 以下三种情况,系统会自动调用拷贝构造函数:
      (1)当使用下面的声明语句,用一个已存在的对象初始化一个新对象时,系统会自动调用拷贝构造函数:
      <类名><新对象名>(<已存在对象名>);
      或 <类名><新对象名>=<已存在对象名>;
      (2)对象作为实参,在函数调用开始进行实参和形参结合时,会自动调用拷贝构造函数,完成由已知的实参对象初始化形参新对象的功能;
      (3)如果函数的返回值是类的对象,在函数调用完成返回时,系统自动调用拷贝构造函数,用return后面的已知对象来初始化一个临时新对象(所创建的临时对象只在外部表达式范围内有效,表达式结束时,系统将自动调用析构函数撤销该临时对象)。

    **例如:**在主函数中需要用一个已知的IntArray类对象来初始化一个新的IntArray类对象,直接用系统提供的默认拷贝构造函数会出现问题(两个对象指向一个内存空间,系统回收内存空间时会出现报错)以及解决方法如下:

    #include<iostream>
    using namespace std;
    
    class IntArray
    {
    	public:
    		IntArray(int sz)
    		{
    			m_size=sz;
    			m_ptr=new int[sz];
    		}
    		IntArray()
    		{
    			m_size=10;
    			m_ptr=new int[m_size];
    		}
    		void displayArraySize()
    		{
    			cout<<"The size is:"<<m_size<<endl;
    		 } 
    		 ~IntArray()
    		 {
    		 	cout<<"Destructing Array with size:"<<m_size<<endl;
    		 	delete []m_ptr;//收回额外空间 
    		  } 
    		  IntArray(IntArray &x) //拷贝构造函数 
    		  {
    		  	m_size=x.m_size;
    		  	m_ptr=new int[m_size];
    		   } 
    		  private:
    		  	int m_size;
    		  	int *m_ptr;
    		//整型指针在用之前需要给他分配一个内存空间,分配内存空间之后把 分配内存空间首地址赋给m_ptr 
    };
    int main(){
    	IntArray x(20);
    	IntArray y(x);//调用系统默认的拷贝构造函数, 用已存在对象x初始化y 
    	x.displayArraySize();
    	y.displayArraySize();
    	return 0;
    }
    

    关于上述程序的理解:
    1、浅拷贝的内存空间只有一个,在y中被析构函数销毁后继续释放X的内存空间就会出现错误 。
    2、如果一个类中没有指针成员变量的话,一般用浅拷贝就可以了,如果一个类中有指针成员变量的话,一般需要定义一个拷贝构造函数实现深拷贝 。

    展开全文
  • 构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值。 默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。这样在创建对象时就...

    类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。
    构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值。
    默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值。

    //例程:无参构造函数和有参构造函数在创建对象时初始化的使用
    #include <iostream>
    #include <cstdio>
    #include <cmath>
    using namespace std;
    
    class Point{
    public:
    	Point(){
    		printf("无参构造函数\n");
    	}
    	Point(int x, int y):x(x),y(y){
    		printf("有参构造函数初始化\n");
    	};
    
    	void show(){
    		printf("Point[x=%d, y=%d]\n", x, y);
    	}
    
    	void setX(int x){
    		this->x = x;
    	}
    	int getX(){
    		return x;
    	}
    	void setY(int y){
    		this->y = y;
    	}
    	int getY(){
    		return y;
    	}
    
    private:
    	int x, y;
    };
    
    class Line{
    public:
    	Line(Point& p1, Point& p2):p1(p1),p2(p2){};
    
    	float dist(){
    		return sqrt( (p1.getX()-p2.getX() ) * ( p1.getX()-p2.getX() ) + ( p1.getY()-p2.getY() ) * ( p1.getY()-p2.getY() ) );
    	}
    private:
    	Point p1, p2;
    };
    
    int main(){
    	Point p1;
    	p1.setX(6);
    	p1.setY(8);   //无参构造函数初始化
    	p1.show();
    
    	Point p2(3, 4);   //有参构造函数初始化
    	p2.show();
    
    	Line line(p1, p2);
    	printf("dist=%f\n", line.dist());
    }
    

    运行结果(Eclipse):
    在这里插入图片描述

    展开全文
  • 构造函数和析构函数

    2021-03-03 17:22:50
    没有任何返回类型的声明。 构造函数的目的:初始化对象。 调用: 自动调用(隐式) 一般情况下C++编译器会自动调用构造函数(参构造) 手动调用(显示) 在一些情况下则需要手工调用构造函数(有参构造) 构造函数的分类...

    构造函数和析构函数

    一、构造函数

    定义:

    C++中的类可以定义与类名相同的特殊成员函数,这种与类名相同的成员函数叫做构造函数
    构造函数在定义时可以有参数,因此可以 发生重载;
    没有任何返回类型的声明。

    构造函数的目的:初始化对象。

    调用:

    自动调用(隐式)	一般情况下C++编译器会自动调用构造函数(无参构造)
    手动调用(显示)	在一些情况下则需要手工调用构造函数(有参构造)
    

    构造函数的分类

    无参构造函数、有参构造函数、拷贝构造函数、移动构造函数

    1、无参构造函数
    直接创建对象即可自动调用
    注意:不要在对象后面加(),无参构造函数不能显式调用

    2、有参构造函数(有三种调用方法)

    	//括号法
    	A a(2,"哈哈");
    	//匿名对象
    	A b = A(1, "喜喜");
    	//等号法
    	A c = { 3,"啊啊" };
    

    对象的初始化和对象的赋值是两个不同的概念
    注意:
    如果没有写有参构造函数,那么C++编译器会自动帮我们生成一个无参构造函数
    如果写了有参构造函数,那么就不会帮我们生成了,必须自己写一个无惨构造函数,才能直接

    定义对象

    3、拷贝构造函数(赋值构造函数)

    1、浅拷贝(shallowCopy)只是增加了一个指针指向已存在的内存地址

    2、深拷贝(deepCopy)是增加了一个指针并且申请了一个新的内存,使这个增加的指针指向这个新的内存。

    使用深拷贝的情况下,释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。

    用一个对象去初始化另一个对象时,需要拷贝构造

    	
    	Stu(const Stu& other)
    	{
    		m_age = other.m_age;
    		//浅拷贝写法
    		//m_name = other.m_name;	
    		//深拷贝写法
    		m_name = new char[strlen(other.m_name) + 1];
    		strcpy(m_name, other.m_name);
    	}
    

    注意:定义之后,匿名对象法不能使用,进行赋值不会调用拷贝构造函数

    4、移动构造函数

    	Stu(Stu&& other)
    	{
    		m_age = other.m_age;
    		m_name = other.m_name;
    
    		other.m_name = nullptr;
    	}
    	调用
    	
    	用在拷贝
        //指针方式
    	Stu nan(std::move(maye));	//maye不可以再使用了,因为它的内存给了nan  move()转为右值
    	//常规
    	Stu nan(maye);	
    

    内存进行拷贝,拷贝空间是需要时间的,而且在大型数据时,更久。

    优点:减少时间和空间的浪费。

    5、委托构造
    简便

    	//原来  
    	Stu(const char* name)
    	{
    		
    		m_name = new char[strlen(name) + 1];
    		strcpy(m_name, name);
    	}
    	Stu(int age) //委托构造
    	{
    		m_name = new char[strlen(name) + 1];
    		strcpy(m_name, name);
    		m_age = age;
    	}
    	//改成委托构造
    		Stu(const char* name)
    	{
    		m_name = new char[strlen(name)+1];
    		strcpy(m_name, name);
    	}
    	Stu(int age):Stu("null")	//委托构造
    	{
    		m_age = age;
    	}
    

    二、析构函数

    定义:

    C++中的类可以定义一个特殊的成员函数清理对象,这个特殊的成员函数叫做析构函数

    语法:~类名()
    特点

    析构函数没有参数,因此不可以发生重载
    没有任何返回类型的声明
    析构函数在对象销毁时自动被调用
    

    目的:清理对象

    //析构函数
    	~Stu()
    	{
    		if (m_name)
    		{
    			delete[] m_name;
    			m_name = nullptr;
    		}
    		cout << "我是析构函数" << endl;
    	}
    

    构造和析构顺序:

    构造:
    先创建的对象先构造
    后创建的对象后构造

    析构:
    先创建的对象后释放
    后创建的对象先释放

    展开全文
  • 构造函数的特点:以类名作为函数名,无返回类型。常见的构造函数有三种写法:构造函数一般构造函数复制构造函数C++的构造函数可以有多个,创建对象时编译器会根据传入的参数不同调用不同的构造函数。1、构造...
  • C++ 构造函数总结

    万次阅读 多人点赞 2017-05-10 16:57:22
    构造函数的名字必须与类名相同,构造函数不具有任何类型,不返回任何值(与void类型不同,不是返回空,而是没有返回值)。1.参数的构造函数#include using namespace std;class Time { public
  • (3)public ,返回值,无需定义返回类型; (4)允许重载,可以定义多个 (5)尽量简单,太复杂、包含大量逻辑处理的 (6)初始化工作建议用单独的Init()方法实现 (7)避免对象创建时出错 this是一个指针 ,指向对象...
  • C++是面向对象的编程语言呢,具有类class,类的初始化就需要调用类的构造函数,默认调用类的构造...2)、不包含任何返回类型,也不能写成void类型; 3)、一个类可以有多个构造函数(即构造函数重载),也可以没...
  • 类的构造函数的名称与类的名称同名,不返回任何类型,它在每次创建类的新对象时自动调用。 1.构造函数 构造函数即默认调用的构造函数。 2.有参构造函数 创建新对象时,传进去对应参数,即可初始化。 3....
  • c#构造函数

    2019-08-12 22:20:33
    //声明基本的构造函数的语法就是声明一个和所在类同名的方法,但是该方法没有返回类型 public class Myclass{ public Myclass(){ 这个构造函数的函数体 } } 当我们使用new关键字创建类的时候就会调用构造函数 注意:...
  • C++的默认构造函数

    2021-04-08 11:06:11
    构造函数:类进行实例化时调用的函数,该函数无返回类型 默认构造函数:无需提供初始值(或者说无参数)的构造函数 如果没有定义任何构造函数,则编译器会自动定义默认构造函数。 编译器自动提供的默认构造函数的...
  • 构造函数名字与类名相同,无返回类型。  3.可以由用户自己定义实现,根据需要设计对数据成员进行初始化,依旧可以设置函数的默认参数。  4.如果我们没有定义构造函数,系统会为我们自动定义一个参的默认构造...
  • 构造函数名字与类名相同,无返回类型。  3.可以由用户自己定义实现,根据需要设计对数据成员进行初始化,依旧可以设置函数的默认参数。  4.如果我们没有定义构造函数,系统会为我们自动定义一个参的默认构造...
  • (二)析构函数析构函数的...②不返回任何值,没有函数类型,也没有函数参数,由于函数参数,则不能被重载,一个类只能有一个析构函数,但可以有多个构造函数。 ③一般情况下,在声明类的同时就定义析构函数。 ...
  • 构造函数

    2017-06-27 10:04:00
    (2)构造方法没有返回类型,也不能定义为void,在方法名前面不声明方法类型。 (3)构造方法的主要作用是完成对象的初始化工作,它能够把定义对象时的参数传给对象的域。 (4)一个类可以定义多个构造方法,如果...
  • (一)构造函数:(分为有参数和参数两种) ...3)没有任何返回类型的声明。b:作用:完成对参数的初始化 构造函数建立例子:class Test //定义一个类 { public: Test() //参数构造函数 { //
  • 1.static关键字修饰,无返回类型参数的构造函数 2.不能通过代码显式的调用静态构造函数 3.静态构造函数在类的静态成员第一个范文或第一个类实例创建之前由系统调用 4.静态构造函数最多运行一次 5.静态构造函数...
  • c++类的构造函数

    2019-09-29 16:52:30
    构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。 构造函数可用于为某些成员变量设置初始值。 ·构造函数 下面为实例: 1 #include<iostream> 2 using namespace...
  • 1:构造函数 处理对象的初始化。特殊的成员函数,不需要用户来调用,而是在建立对象的时候自动执行。 特点: ①与类名相同 ②没有任何返回类型 ③定义时可以有参数,可以参数 2:析构函数 语法 :~classname() ...
  • 构造函数: 1,构造函数名必须和类名一样、一般函数不用 2,构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰....简而言之,构造函数无返回值类型定义! ...
  • 没有任何函数返回类型 因为只有一个形参且返回类型,因而不能重载拷贝构造函数 形式:<类名>(<类名> &对象名) 没用明显定义时,系统自动给出默认拷贝构造函数——“浅拷贝” 某些情况下,用户...
  • 第六课 1,构造函数 ·创建一个对象时,常常需要做某些初始化的工作,例如对数据成员赋初值;...·没有任何返回类型的声明; 1.2调用: ·自动调用(隐式):一般情况下,C++编译器会自动调用构造函数(
  • c#静态构造函数

    千次阅读 2010-12-04 04:02:00
    c#静态构造函数,又称类构造函数。它是属于类的,不属于任何一个...它具有以下特点:1、以static定义的,访问修饰符,无返回类型参数的构造函数,如: Code: class test { /// /// 静态构造函数/类构造函数
  • 构造函数必须要与 类同名,构造函数一定不能够有返回类型,切记void也是一种返回类型! 如果在类中没有创建任何构造函数,那么系统将使用默认的构造函数,如果程序员定义了一个构造函数,那么默认的构造函数将不存在...
  • java构造函数

    2015-05-20 10:20:03
    (2)构造方法没有返回类型,也不能定义为void,在方法名前面不声明方法类型。(3)构造方法的主要作用是完成对象的初始化工作,它能够把定义对象时的参数传给对象的域。(4)一个类可以定义多个构造方法,如果在定义类时...
  • java中的构造函数

    2018-07-12 20:16:48
    java中,类的生成需要构造方法,以下对构造方法进行一些总结。1 构造方法与一般方法主要区别体现在以下三个方面: (1)修饰符:构造方法可以带... (2)返回类型:普通函数必须含有返回类型,即使没有返回值,...
  • 浅谈构造函数(c#)

    2012-01-31 15:38:34
    构造函数具有与类相同的名称却无任何返回类型,是在创建给定类型的对象时执行的类方法。 二:构造函数作用? 它通常初始化新对象的数据成员。 三:构造函数何时被调用? 构造函数是在类实例化之前执行的,而类中...
  • Java构造函数的说明。

    千次阅读 2013-05-10 21:09:58
    2.构造函数不返回任何值,也没有返回类型(包括void) 3.每一个类可以有一个或多个构造方法; 4.构造方法在创建对象时自动执行,不用显式地直接调用。 实现形式: 1.系统默认的构造方法。 2.自定义构造方法与...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 190
精华内容 76
关键字:

构造函数无任何函数返回类型