构造函数 订阅
构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。 展开全文
构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。
信息
作    用
为对象成员变量赋初始值
语    句
new运算符一起使用
中文名
构造函数
外文名
constructor
构造函数主要特点
1.构造函数的命名必须和类名完全相同。在java中普通函数可以和构造函数同名,但是必须带有返回值;2.构造函数的功能主要用于在类的对象创建时定义初始化的状态。它没有返回值,也不能用void来修饰。这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择。而其他方法都有返回值,即使是void返回值。尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的;3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用;而一般的方法是在程序执行到它的时候被调用的;4.当定义一个类的时候,通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略,不过Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的。而一般的方法不存在这一特点;5.构造函数有回滚的效果,构造函数抛出异常时,构造的是一个不完整对象,会回滚,将此不完整对象的成员释放(c++)6.当一个类只定义了私有的构造函数,将无法通过new关键字来创建其对象,当一个类没有定义任何构造函数,C#编译器会为其自动生成一个默认的无参的构造函数。7.在Python中构造函数必须通过重写__init__方法实现
收起全文
精华内容
下载资源
问答
  • JAVA构造函数(方法)

    万次阅读 多人点赞 2019-06-03 21:56:24
    一、什么是构造函数 java构造函数,也叫构造方法,是java中一种特殊的函数。函数名与相同,无返回值。 作用:一般用来初始化成员属性和成员方法的,即new对象产生后,就调用了对象了属性和方法。 在现实生活中,...

    一、什么是构造函数

    Java构造函数,也叫构造方法,是JAVA中一种特殊的函数。与函数名相同,无返回值。

    作用:一般用来初始化成员属性和成员方法的,即new对象产生后,就调用了对象的属性和方法。

    在现实生活中,很多事物一出现,就天生具有某些属性和行为。比如人一出生,就有年龄、身高、体重、就会哭;汽车一出产,就有颜色、有外观、可以运行等。

    这些,我们就可以将这些天然的属性和行为定义在构造函数中,当new实例化对象时,也就具有这些属性和方法,不用再去重新定义,从而加快编程效率。

    构造函数是对象一建立就运行,给对象初始化,就包括属性,执行方法中的语句。

    而一般函数是对象调用才执行,用 ".方法名" 的方式,给对象添加功能。

     一个对象建立,构造函数只运行一次。

     而一般函数可以被该对象调用多次。  

     

    二、构造函数的特点

    1、函数名与类名相同

    2、不用定义返回值类型。(不同于void类型返回值,void是没有具体返回值类型;构造函数是连类型都没有)

    3、不可以写return语句。(返回值类型都没有,故不需要return语句)

    注:一般函数不能调用构造函数,只有构造函数才能调用构造函数。

     

     三、示例

    1、无参构造函数类中只定义一个方法。构造器总是伴随着new操作一起调用. 

    new对象时,就调用与之对应的构造函数,执行这个方法。不必写“.方法名”。

    package javastudy;
    
    public class ConfunDemo {
        public static void main(String[] args) {
            //输出Hello World。new对象一建立,就会调用对应的构造函数Confun(),并执行其中的println语句。
            Confun c1=new Confun();            
            
        }
    }
    class Confun{        
        Confun(){        
            //定义构造函数,输出Hello World
            System.out.println("Hellow World");
        }
    }

    输出:

    Hellow World 

     

     2、有参构造函数,在new对象时,将实参值传给private变量,相当于完成setter功能。

    package javastudy;
    
    public class ConfunDemo3 {
        public static void main(String[] args){
            //实例化对象时,new Person()里直接调用Person构造函数并转转实参,相当于setter功能
            Person z = new Person("aerchi",18); 
            z.show();
        }
    }
    
    class Person{
        private String name;
        private int age;
        //有参数构造函数,实现给private成员变量传参数值的功能
        public Person(String n,int m){ 
            name=n;
            age=m;        
        }
        //getter                                      
        //实例化对象时,完成了sett功能后,需要getter,获取实参值。
        public String getName(){
            return name;
        }
        public int getAge(){
            return age;
        }
    
        //获取private值后,并打印输出
        public void show(){
            System.out.println(name+"\n"+age);
        }
    }

    输出:

    aerchi
    18

     以上代码,我们也可以将show()方法中的输出语句直接放在构造函数中,new对象时,即可直接输出值,如下

    package javastudy;
    
    public class ConfunDemo3 {
        public static void main(String[] args){
            //实例化对象时,new Person()里直接调用Person构造函数并转转实参,同时执行输出语句
            Person z=new Person("aerchi", 18);
        }
    }
    
    class Person{
        private String name;
        private int age;
        //有参数构造函数,实现给private成员变量传参数值的功能,同时直接输出值
        public Person(String n,int m){  
            name = n;
            age = m;
            System.out.println(name+"\n"+age);
        }
    }

    输出:

    aerchi
    18

     或

    class ConFun
    {
        public static void main(String[] args){
            Person a=new Person(18,"aerchi");
            System.out.println(a.getAge() +", " + a.getName());
        }
    }
    
    class Person
    {
        private int age;
        private String name;
        public Person(int x,String y){
            age=x;
            name=y;
        }
        public int getAge(){
            return age;
        }
        public String getName(){        
            return name;
        }
    }

     

    3、一个对象建立后,构造函数仅只运行一次。

    如果想给对象的值再赋新的值,就要使用set和get方法,此时是当做一般函数使用

    如下:

    package javastudy;
    
    public class ConfunDemo4 {
        public static void main(String[] args) {
                PersonDemo s=new PersonDemo("张三",18);  //new对象时,即调用对应的构造函数,并传值。同时,不能new同一个对象多次,否则会报错。
                s.setName("李四");                       //对象建立后,想变更值时,就要用set/get方法,重新设置新的值
                s.setName("王二麻子");    //并可调用对象多次。
                s.print();
        }
    }
    class PersonDemo{
        private String name;
        private int age;
        PersonDemo(String n,int m){       //建立有参构造函数,用于给两个private变量name、age赋值,同时输出值
            name=n;
            age=m;
            System.out.println("姓名:"+name+"\n"+"年龄:"+age);
        }
        public void setName(String x){     //set方法,用于再次给name赋值
            name=x;        
        }
        public String getName(){          //get方法,用于获取name的赋值
            return name;
        }
        public void print(){
            System.out.println(name);
        }
    }

    输出结果:

    姓名:张三
    年龄:18
    王二麻子

     

    四、默认构造函数

    当一个类中没有定义构造函数时,系统会给该类中加一个默认的空参数的构造函数,方便该类初始化。只是该空构造函数是隐藏不见的。

    如下,Person(){}这个默认构造函数是隐藏不显示的。

    class Person
    {  
        //Person(){}
    }

    当在该类中自定义了构造函数,默认构造函数就没有了。

    如果仍要构造函数,需要在类中手动添加。

     

    五、构造函数的重载

    构造函数也是函数的一种,同样具备函数的重载(Overloding)特性。

    class Person
    {  
        private String name;
        private int age;
     
        Person()
        {
            System.out.println("A:name="+name+", age="+age);
        }
     
        Person(String n)
        {
            name = n;
            System.out.println("B:name="+name+", age="+age);
        }
     
        Person(String n,int a)
        {  
            name=n;
            age=a;
            System.out.println("C:name="+name+", age="+age);
        }
     
    }
     
    class PersonDemo2
    {
        public static void main(String[] args)
        {
            Person p1=new Person();
            Person p2=new Person("aerchi");
            Person p3=new Person("aerchi",18);
        }
    }

    输出结果:

    A:name=null, age=0
    B:name=aerchi, age=0
    C:name=aerchi, age=18

     

    class Person
    {  
        private String name;
        private int age;
     
        Person()
        {
            System.out.println("A:name="+name+", age="+age);
            cry();
        }
     
        Person(String n)
        {
            name = n;
            System.out.println("B:name="+name+", age="+age);
            cry();
        }
     
        Person(String n,int a)
        {  
            name=n;
            age=a;
            System.out.println("C:name="+name+", age="+age);
            cry(); 
        }
        void cry()
        {
            System.out.println("Haha ...............");
        }
     
    }
     
    class PersonDemo2
    {
        public static void main(String[] args)
        {
            Person p1=new Person();
            Person p2=new Person("aerchi");
            Person p3=new Person("aerchi",18);
        }
    }

    输出结果:

    A:name=null, age=0
    Haha ...............
    B:name=aerchi, age=0
    Haha ...............
    C:name=aerchi, age=18
    Haha ...............

     

    六、构造函数的使用

     1、子类所有的 构造函数 默认调用父类的无参构造函数(构造函数不会被继承,只是被子类调用而已),父类参数是private的,无法直接访问。需要在父类中使用get方法来调用私有变量值。

    package javastudy;
    
    public class ConfunDemo5 {
        public static void main(String[] args) {
            Pupil z=new Pupil();
            z.show();
        }
    }
    class Student{                //父类Student
        private String name;
        private int height;
        public Student()
        {
            this.name="";
            this.height=0;
        }
        public String getName(){
            return name;
        }
        public int getHeight(){
            return height;
        }
    }
    class Pupil extends Student{    //子类Pupil
        private int score;
        public Pupil(){                //无参构造函数Pupil()直接继承了父类中的无参构造函数Student(),但是父类中的name、height是private的
            score=0;
        }
        public void show(){
            System.out.print("姓名:"+getName()+"\n身高:"+getHeight()+"\n分数:"+score);  //输出时,直接用get方法名。
        }
    }

    2、使用super调用父类的构造函数

     super 必须写在方法的首行

    package javastudy;
    
    public class ConfunDemo5 {
        public static void main(String[] args) {
            Pupil z=new Pupil("王二麻子",100,200);
            z.show();
            
            Pupil w=new Pupil();
            w.show();
        }
    }
    class Student{                //父类Student
        public String name;
        public int height;
        public Student()
        {
            this.name="";
            this.height=0;
        }
        public Student(String n,int m)
        {
            name=n;
            height=m;
        }
    }
    class Pupil extends Student{    //子类Pupil
        private int score;
        public Pupil(){                
            super("刘德花",501);    //使用super调用父类Student(String n,int m)方法,同时传递实际数值。super必须写在方法的首行。如果这里写super(),则调用的是父类中的Student()方法。
            score=0;
        }
        public Pupil(String x,int y,int z){        //
            super(x,y);              //使用super调用父类Student(String n,int m)方法,其中super中的参数名称必须与构造函数中的参数名称一致。
            score=z;
        }
        public void show(){
            System.out.println("姓名:"+name+"\n身高:"+height+"\n分数:"+score);
        }
    }

     输出:

    姓名:王二麻子
    身高:100
    分数:200
    姓名:刘德花
    身高:501
    分数:0

    打杂人

    展开全文
  • 构造函数

    千次阅读 2016-03-07 22:28:52
    构造函数  类通过一个或几个特殊的成员函数控制类对象初始化过程这样的成员函数为构造函数构造函数的函数名与类名相同,没有返回类型,不能声明为const成员函数(因为直到构造函数初始化过程后,对象才能真正的...

    构造函数

       类通过一个或几个特殊的成员函数控制类对象初始化过程这样的成员函数为构造函数。构造函数的函数名与类名相同,没有返回类型,不能声明为const成员函数(因为直到构造函数初始化过程后,对象才能真正的取得其常量属性)一个类中可以有多个构造函数。构造函数有一个初始化列表。

     

    &构造函数初始化列表:

      构造函数初始化时,每个成员函数只能初始化一次,虽然成员函数的形参顺序必须与实参顺序相同,但是构造函数的舒适化列表与顺序无关。(最好使构造函数的初始值列表与成员声明顺序相同。如果可能的话,应该尽量减少使用某些某些去初始化另外的成员)。

      构造函数的初始化与赋值不同,如果没有在构造函数初始化列表中显示的初始化成员,则该成员将在构造函数之前执行默认初始化,然后在函数体中如果有赋值操作,将用默认的初始化内容擦去,用新值代替。

     

     

    &默认构造函数:

       一般的类通过一个特殊的构造函数来是的数据成员初始化为默认值,这种构造函数就默认构造函数。当我们在类中没有显示的构造函数时,编译器就会隐式的定义一个默认构造函数成为合成的默认构造函数。这种合成的默认构造函数初始化规则就是 如果存在类内的初始值,用它来初始化,否则默认初始化该成员。显然如果类成员中油内置类型或复合类型,那么这些成员最好有初始值,否则生成的合成的默认构造函数可能会出现未定义的现象。如果类中有构造函数,同时也想享受合成的默认构造函数机制那么就用=default关键字。与此同时,如果类中有一个类类型数据成员,那么只有这个数据成员有合成默认构造函数时才能生成默认构造函数,否则不能生成。基于这种情况,如果向生命默认构函数,则直接列表初始化。

    &默认实参与构造函数:

      如果一个构造函数为所有的类成员提供了默认实参,那么实际上也就为类提供了默认构造函数。使用默认实参的作用之一是在于将默认构造函数与某些构造函数相结合。另一作用是对于部分不同数据成员的初始化对另外几个数据成员有着约束作用。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • c++ 构造函数详解

    万次阅读 多人点赞 2019-05-31 17:20:58
    c++构造函数详解。(构造函数的分类、拷贝构造函数

    c++ 构造函数详解

    构造函数是干什么的

    • 该类对象被创建的时候,编译系统对象分配内存空间,并自动调用该构造函数,由构造函数完成成员的初始化工作,故:构造函数的作用:初始化对象的数据成员

    构造函数的分类

    • 无参构造函数
    • 带默认值的构造函数
    • 有参(无默认值)的构造函数
    • 复制构造函数(拷贝构造函数)
      • 一种特殊的构造函数,当对象之间复制时会自动调用拷贝构造函数
      • 若类中没有显示定义拷贝构造函数,则系统会自动生成默认拷贝构造函数
    	#include <iostream>
    	using namespace std;
    	
    	class Coordinate
    	{
    	public:
    		// 无参构造函数
    		// 如果创建一个类你没有写任何构造函数,则系统自动生成默认的构造函数,函数为空,什么都不干
    		// 如果自己显示定义了一个构造函数,则不会调用系统的构造函数
    		Coordinate()
    		{
    			c_x = 0;
    			c_y = 0;
    		}     
    	
    		// 一般构造函数
    		Coordinate(double x, double y):c_x(x), c_y(y){}   //列表初始化
    		// 一般构造函数可以有多个,创建对象时根据传入的参数不同调用不同的构造函数
    	
    		Coordinate(const Coordinate& c)
    		{
    			// 复制对象c中的数据成员
    			c_x = c.c_x;
    			c_y = c.c_y;
    		}
    	
    		// 等号运算符重载
    		Coordinate& operator= (const Coordinate& rhs)
    		{
    			// 首先检测等号右边的是否就是等号左边的对象本身,如果是,直接返回即可
    			if(this == &rhs)
    				return* this;
    			// 复制等号右边的成员到左边的对象中
    			this->c_x = rhs.c_x;
    			this->c_y = rhs.c_y;
    			return* this;
    		}
    	
    		double get_x()
    		{
    			return c_x;
    		}
    	
    		double get_y()
    		{
    			return c_y;
    		}
    	
    	private:
    		double c_x;
    		double c_y;
    	};
    	
    	int main()
    	{
    		// 调用无参构造函数,c1 = 0,c2 = 0
    		Coordinate c1, c2;
    		// 调用一般构造函数,调用显示定义构造函数
    		Coordinate c3(1.0, 2.0);
    		c1 = c3;    //将c3的值赋值给c1,调用"="重载
    		Coordinate c5(c2);
    		Coordinate c4 = c2;    // 调用浅拷贝函数,参数为c2
    		cout<<"c1 = "<<"("<<c1.get_x()<<", "<<c1.get_y()<<")"<<endl
    			<<"c2 = "<<"("<<c2.get_x()<<", "<<c2.get_y()<<")"<<endl
    			<<"c3 = "<<"("<<c3.get_x()<<", "<<c3.get_y()<<")"<<endl
    			<<"c4 = "<<"("<<c4.get_x()<<", "<<c4.get_y()<<")"<<endl
    			<<"c5 = "<<"("<<c5.get_x()<<", "<<c5.get_y()<<")"<<endl;
    		return 0;
    	}
    
    	c1 = (1, 2)
    	c2 = (0, 0)
    	c3 = (1, 2)
    	c4 = (0, 0)
    	c5 = (0, 0)
    	请按任意键继续. . .
    

    拷贝构造函数

    • 拷贝构造函数是一种特殊的构造函数,具有单个形参,该形参(常用const修饰)是对该类型的引用。当定义一个新对象并用同一类型的对象都它进行初始化时,将显示使用拷贝构造函数,当该类型的对象传递给函数返回该类型的对象时,将隐式调用拷贝构造函数
    • 当类中有一个数据成员是指针时,或者有成员表示在构造函数中分配的其他资源,必须显示定义拷贝构造函数
    • 构造函数的使用情况
      • 一个对象以值传递的方式传入函数体
      • 一个对象以值传递的方式从函数体返回
      • 一个对象需要通过另一个对象进行初始化
    	#include <iostream>
    	using namespace std;
    	
    	class Test
    	{
    	public:
    		// 构造函数
    		Test(int a):t_a(a){
    		cout<<"creat: "<<t_a<<endl;
    		}
    	
    		// 拷贝构造函数
    		Test(const Test& T)
    		{
    			t_a = T.t_a;
    			cout<<"copy"<<endl;
    		}
    	
    		// 析构函数
    		~Test()
    		{
    			cout<<"delete: "<<t_a<<endl;
    		}
    	
    		// 显示函数
    		void show()
    		{
    			cout<<t_a<<endl; 
    		}
    	
    	private:
    		int t_a;
    	};
    	
    	// 全局函数,传入的是对象
    	void fun(Test C)
    	{
    		cout<<"test"<<endl;
    	}
    	
    	int main()
    	{
    		Test t(1);
    		// 函数中传入对象
    		fun(t);
    		return 0;
    	}
    
    	creat: 1
    	copy
    	test
    	delete: 1
    	delete: 1
    	请按任意键继续. . .
    

    浅拷贝与深拷贝

    • 浅拷贝
      • 所谓浅拷贝,指的是在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝。也就是增加了一个指针,指向原来已经存在的内存。 正常情况下,“浅拷贝”已经能很好的工作,但是一旦对象存在动态成员,浅拷贝就会出问题。让我们考虑下面一段代码:
    	#include <iostream>
    	#include <assert.h>    
    	using namespace std;
    	
    	class Test
    	{
    	public:
    		Test(){
    			p = new int(10);
    		}
    	
    		~Test(){
    			assert(p != NULL);     // assert()作用是如果他的条件返回错误,则终止程序执行 
    			delete p;
    		}
    	private:
    		int x;
    		int y;
    		int* p;
    	};
    	
    	int main()
    	{
    		Test t1;
    		Test t2(t1);    // 调用默认拷贝构造函数
    		return 0;
    	}
    

    上述程序崩溃。在使用t1复制t2时,进行的是浅拷贝,只是将成员的值进行赋值。此时,t1.p = t2.p, 即两个指针指向了堆里的同一个空间。这样,析构函数会被调用两次,这就是错误出现的原因。此问题的解决方法是“深拷贝”。

    • 深拷贝
      • 深拷贝就是对于对象中的动态成员,并不只是简单的赋值,而是重新分配空间,即资源重新分配。上述代码处理如下:
    	#include <iostream>
    	#include <assert.h>    
    	using namespace std;
    	
    	class Test
    	{
    	public:
    		Test(){
    			x = 0;
    			y = 0;
    			p = new int(10);
    		}
    	
    		Test(const Test& t)
    		{
    			x = t.x;
    			y = t.y;
    			p = new int(10);
    			*p = *(t.p);
    		}
    	
    		~Test(){
    			assert(p != NULL);     // assert()作用是如果他的条件返回错误,则终止程序执行 
    			delete p;
    		}
    	
    		int get_x(){return x;}
    		int get_y(){return y;}
    	private:
    		int x;
    		int y;
    		int* p;
    	};
    	
    	int main()
    	{
    		Test t1;
    		Test t2(t1);    // 调用默认拷贝构造函数
    		cout<<"("<<t1.get_x()<<", "<<t1.get_y()<<")"<<endl
    			<<"("<<t2.get_x()<<", "<<t2.get_y()<<")"<<endl;
    		return 0;
    	}
    
    (0, 0)
    (0, 0)
    请按任意键继续. . .
    

    此时t1与t2的p各自指向一段内存空间,但他们指向的内容相同,这就是“深拷贝”。

    展开全文
  • C++的构造函数和默认构造函数详解

    万次阅读 多人点赞 2019-04-07 15:19:45
    C++的构造函数和默认构造函数 今天学习c++时突然感觉自己对构造函数和默认构造函数的区别有些分不清,于是查找了各大网站将资料汇总一下,供自己和其他朋友们参考。 构造函数是c++的类在构造对象时调用的函数,此...

    C++的构造函数和默认构造函数详解

    构造函数是c++面向对象中的一个重难点,于是我查找了各大网站将资料汇总一下,供自己和其他朋友们参考。

    首先我们来看看构造函数的分类:

    class Complex 
    {         
     
    private :
        double m_real;
        double m_imag;
     
    public:
     
        // 无参构造函数
        // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数,函数为空
        // 只要你写了一个下面的某一种构造函数,系统就不会再自动生成这样一个
        //默认构造函数,如果希望有一个这样的无参构造函数,则需要自己显式地写出来
        Complex(void)
        {
             m_real = 0.0;
             m_imag = 0.0;
        } 
             
        // 一般构造函数
        // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数,前提
        //是参数的个数或者类型不同(基于c++的重载函数原理)
        // 例如:你还可以写一个 Complex( int num)的构造函数出来
        // 创建对象时根据传入的参数不同调用不同的构造函数
        Complex(double real, double imag)
        {
             m_real = real;
             m_imag = imag;         
         }
         
        // 复制构造函数(拷贝构造函数)
        // 复制构造函数参数为类对象本身的引用,用于根据一个已存在的对象
        //复制出一个新的该类的对象,一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
        // 若没有显示的写复制构造函数,则系统会默认创建一个复制构造函数,但当类中
        //有指针成员时,由系统默认创建该复制构造函数会存在风险
        Complex(const Complex & c)
        {
            // 将对象c中的数据成员值复制过来
            m_real = c.m_real;
            m_img  = c.m_img;
        }            
     
        // 类型转换构造函数,根据一个指定的类型的对象创建一个本类的对象
        // 例如:下面将根据一个double类型的对象创建了一个Complex对象
        Complex::Complex(double r)
        {
            m_real = r;
            m_imag = 0.0;
        }
     
        // 等号运算符重载
        // 注意,这个类似复制构造函数,将=右边的本类对象的值复制给等号
        //左边的对象,它不属于构造函数,等号左右两边的对象必须已经被创建
        // 若没有显示的写=运算符重载,则系统也会创建一个默认的=运算符重载,只做一些基本的拷贝工作
        Complex &operator=(const Complex &rhs)
        {
            // 首先检测等号右边的是否就是左边的对象本,若是本对象本身,则直接返回
            if ( this == &rhs ) 
            {
                return *this;
            }
                 
            // 复制等号右边的成员到左边的对象中
            this->m_real = rhs.m_real;
            this->m_imag = rhs.m_imag;
                 
            // 把等号左边的对象再次传出
            // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
            // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)    
            return *this;
        }
    };
    
    void main()
    {
        // 调用了无参构造函数,数据成员初值被赋为0.0
        Complex c1,c2;
     
        // 调用一般构造函数,数据成员初值被赋为指定值
        Complex c3(1.0,2.5);
        // 也可以使用下面的形式
        Complex c3 = Complex(1.0,2.5);
             
        // 把c3的数据成员的值赋值给c1
        // 由于c1已经事先被创建,故此处不会调用任何构造函数
        // 只会调用 = 号运算符重载函数
        c1 = c3;
             
        // 调用类型转换构造函数
        // 系统首先调用类型转换构造函数,将5.2创建为一个本类的
        //临时对象,然后调用等号运算符重载,将该临时对象赋值给c1
        c2 = 5.2;
           
        // 调用拷贝构造函数( 有下面两种调用方式) 
        Complex c5(c2);
        Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不
                                      //是事先已经创建的,故需要调用拷贝构造函数,参数为c2       
       
    }
    

    下面再从定义出发,看看构造函数和默认构造函数的区别:

    构造函数是c++的类在构造对象时调用的函数,此函数没有返回类型。
    默认构造函数是未提供显式初始值时用来构建对象的构造函数。

    其实这个定义并没有告诉我们什么详细的细节,真正想要搞懂还是要看看代码,从代码的区别来体会他们两个之间的差异。

    class A
    {
    private:
        int  _a;
        int _b;
    public:
        A();                    // 默认构造函数
        A(int a, int b);        // 构造函数 
        A(int a = 10, int b = 2);    // 默认构造函数
    };
    

    其实如果我们没有提供任何构造函数,系统会自己帮我们加上一个默认构造函数,就像A() {};一样。当然,如你所见这个函数是空的,他不能做任何事,但是他却并不是一无是处,他的作用就是保证程序能够正确运行。

    如果我们要自己定义一个默认构造函数,那我们有两种方法:

    1.定义一个无参的构造函数(例如上面的A(); )
    2.定义所有参数都有默认值的构造函数 (例如上面的 A(int a = 10, int b = 2); )

    重点来了!切记一个类只能有一个默认构造函数!也就是说上面提到的两个方法你只能选其中的一种,不过我们大多数情况下还是选择第一种。

    另外,如果我们已经定义了构造函数,则系统不会再给我们加上默认构造函数了,这也就要求我们最好自己将默认构造函数写上,防止出现未初始化的错误。

    2019年4月7日

    展开全文
  • 构造函数与拷贝构造函数

    千次阅读 多人点赞 2019-04-03 09:07:15
    拷贝构造函数构造函数不能分开说,他们都是初始化对象的一种方法。但是我们这里用构造函数辅助说明拷贝构造函数,主要说说拷贝构造函数的声明,用途和使用注意事项。 众所周知,构造函数是一个初始化类对象的函数...
  • C++拷贝构造函数详解

    万次阅读 多人点赞 2011-02-23 13:39:00
    什么是拷贝构造函数 首先对于普通类型的对象来说,它们之间的复制是很简单的,例如: int a = 100; int b = a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量。 下面看一个类对象...
  • C++中一般创建对象,拷贝或赋值的方式有构造函数,拷贝构造函数,赋值函数这三种方法。 构造函数就是当创建一个类的对象时,它被调用来对类的数据成员进行初始化和分配内存。拷贝构造函数是一种特殊的构造函数,用...
  • C++ 赋值构造函数 复制构造函数

    千次阅读 2018-08-25 15:29:11
    默认构造函数 编译器提供一个不接受任何参数,也不执行任何操作的构造函数,称之为默认构造函数 这是因为创造对象的时候总会调用默认构造函数 Klunk::Klunk() {} //定义 Klunk lunk; //声明 使用默认构造函数 ...
  • 默认构造函数构造函数重载

    万次阅读 多人点赞 2017-09-29 08:15:52
    本文主要总结了默认构造函数的相关用法和构造函数重载,旨在能够对平时的项目开发起到一定的夯实基本功的作用,言简意赅,一目了然。首先需要了解构造函数是用来做什么?该类对象被创建时,编译器为对象分配内存空间...
  • 构造函数成员函数的一种,名字与类名相同,可以有参数,不能有返回值(void也不行)。 一个类可以有多个构造函数。 如果定义类时没写构造函数,则编译器生成一个默认的无参构造函数,这个构造函数不做任何操作。...
  • 构造函数的执行顺序,派生类构造函数 and 父类构造函数 and 成员对象构造函数
  • C++构造函数之委托构造函数

    万次阅读 多人点赞 2016-10-20 22:16:05
    C++11新标准扩展了构造函数初始值的功能,所以委托构造函数就出现了,一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程,或者说他把自己的一些(或全部)职责委托给了其他构造函数。 1.定义: ...
  • 一直搞不懂什么是构造函数,为什么要用构造函数构造函数有什么用,逃避这个问题,今天做了简单的总结: 1.构造函数有什么用? 当你需要大批量的写对象的时候,就需要用到构造函数,它可以方便创建多个对象的实例...
  • C++——构造函数、析构函数以及复制构造函数

    千次阅读 多人点赞 2021-03-09 16:28:49
    文章目录一、构造函数1.1 构造函数是什么?1.2 为什么要有构造函数?1.3 如何使用构造函数?1.4 构造函数的实现二、使用步骤 一、构造函数 在程序执行的过程中,当遇到与对声明语句时,程序会向操作系统申请一定的...
  • C++ 拷贝构造函数和赋值构造函数

    万次阅读 多人点赞 2019-04-06 16:43:35
    在C++中复制控制是一个比较重要的话题,主要包括复制构造函数、重载赋值操作符、析构函数这三部分,这三个函数是一致的,如果类需要析构函数,则它也需要复制操作符 和 复制构造函数,这个规则被称为 C++的“三法则...
  • Kotlin构造函数及多个构造函数

    万次阅读 2018-05-07 17:57:44
    Kotlin构造函数首先 强调一下 如果下面这样行代码是构造函数的话 class ClassName(name:String){}那么每一个Kotlin类只有一个构造函数 没有多个构造函数其实由于代码什么的都是源于国外的 所以在翻译过程中多说...
  • 1.c++编译器会自动调用构造函数//构造函数(与类名相同) //析构函数:没有参数也没有任何返回类型,被自动调用 #include&lt;iostream&gt; using namespace std; class Test { public: Test();//无参构造函数...
  • C++默认构造函数

    万次阅读 多人点赞 2018-02-08 12:43:51
    本文围绕3个问题来理解C++的默认构造函数: 什么是默认构造函数? 默认构造函数什么时候被调用? 编译器在什么情况下会生成默认构造函数? 一. 什么是默认构造函数? 我们一般会认为默认构造函数就是编译器...
  • C++中默认构造函数构造函数初始化列表

    千次阅读 多人点赞 2018-12-13 10:59:45
    1、默认构造函数构造函数 (1)构造函数:C++用于构建类的新对象时需要调用的函数,该函数无返回类型!(注意:是“无”! 不是空!(void))。 (2)默认构造函数:默认构造函数是在调用时不需要显示地传入实参...
  • 构造函数 ,是一种特殊的方法 。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中 。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的...
  • 当父类没有定义默认构造函数,定义了了自定义的构造函数时,子类定义构造函数时需要使用父类定义的构造函数,否则编译报错。 父类:没有定义默认构造函数,而是定义了其余的构造函数 子类的构造函数在定义时...
  • Java构造函数之调用父类构造函数

    万次阅读 2016-09-21 09:54:39
    如果父类提供了无参数的构造函数,此时子类的构造函数就可以不显式的调用父类的构造函数,默认调用父类的无参构造函数。 package com.bjut.StudyTest; class Person { public Person() { Syste
  • 什么是构造函数?什么是构造函数重载? 当新对象被创建的时候,构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下,Java编译器会为这个类创建一个默认的构造函数。 Java中构造函数...
  • C++ 构造函数总结

    万次阅读 多人点赞 2017-05-10 16:57:22
    C++提供了构造函数来处理对象的初始化。构造函数是一种特殊的成员函数,与其他成员函数不同,构造函数不需要用户来调用它,而是建立对象时自动执行。 构造函数的名字必须与类名相同,构造函数不具有任何类型,不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,829,596
精华内容 731,838
关键字:

构造函数