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

    千次阅读 2019-06-02 21:32:29
    构造函数 一、定义:每个类都分别定义了它的对象被初始化的方式。类通过一个或几个特殊的成员函数来控制其对象的初始化过程,这些函数就叫构造函数。(构造函数的任务就是初始化类对象的数据成员,无论何时只要类的...

    构造函数

    一、定义:每个类都分别定义了它的对象被初始化的方式。类通过一个或几个特殊的成员函数来控制其对象的初始化过程,这些函数就叫构造函数。(构造函数的任务就是初始化类对象的数据成员,无论何时只要类的对象被创建,就会执行构造函数。)
    【注】:如果类的设计者没有写构造函数,那么编译器会自动生成一个没有参数的构造函数。
    二、格式(函数名与类名一样,没有返回值)
    例:

    Class Complex{
       private:
          double real,iamg;
       public:
          Complex(double r, double i=0){
          real=r;  iamg=i;
       };
    

    三、举例说明
    1、

       Class Complex{
       private:
            double real,iamg;
       public:
            void Set(double t,double i);
       };
    

    这个Complex类代表复数,没有写构造函数,因此编译器会为Complex类自动生成一个无参的构造函数。下面语句定义或动态生成Complex对象的语句:
    Complex c;//c用无参构造函数进行初始化
    Complex * p=new Complex;//对象* p用无参构造函数初始化
    2、如果为Complex类编写构造函数

       Class Complex{
       private:
          double real,iamg;
       public:
          Complex(double r, double i=0){
          real=r;  iamg=i;
       };
    

    对下列语句进行编译
    (1).Complex c1;//错,Complex类没有无参构造函数(默认构造函数)
    (2).Complex& pc=new Complex;//错,.Complex类没有无参构造函数
    (3).Complex c2(2);//正确,相当于Complex c2(2,0)
    (4).Complex c3(2,4),c4(3,5);//正确
    (5).Complex& pc2=new Complex(3,4);//正确
    四、构造函数在数组中的使用
    具体哪些元素用哪些构造函数进行初始化,取决于定义数组时的写法。
    五、复制构造函数(拷贝构造函数)
    1、什么叫拷贝构造函数:a、需要一个蓝本。b、是一个构造函数
    2、拷贝构造函数是一个特殊的构造函数,名字与类名一致,它的参数是本类型的一个常引用变量。Complex(const Complex & c);
    3、什么时候用拷贝构造函数

    • 当用一个对象去初始化同类的另一个对象时,会引发复制构造函数被调用。例:T a(b);
    • 如果F的参数是类A的对象,那么当F被调用时,类A的复制构造函数将被调用。
     class A {
     public:
        A (){};
     A(A& a){
        cout<<"holle"<<endl;
     }
     };
     void Func(A a)
     {
     }
     int main(){
        A a;
        Func(a);
        return 0;
     }
    

    则加上头文件后执行结果为:holle

    • 如果函数额返回值时类A 的对象,则函数返回时,类A 的复制构造函数被调用。
     class A{
        public:
        int v;
        A (int n){v=n;};
        A(const A & a){
            v=a.v;
            cout<<"holle"<<endl;
    
        }
    };
    A Func(){
        A a(4);
        return a;
    }
    int main(){
        cout<<Func().v<<endl;
        reuturn 0;
    }
    

    则此程序执行的结果为:
    holle
    4
    关于拷贝的深拷贝与浅拷贝请参考我的另外一篇博客:c++拷贝(shallow/deep拷贝)

    展开全文
  • 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

    打杂人

    展开全文
  • 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日

    展开全文
  • 1.默认构造函数:如果类中没有定义构造函数那么程序会默认的为类创建一个无参数构造函数用以对类进行实例化,如果有构造函数的话,那么程序就不会创建默认构造函数 2静态构造函数,不能访问实例成员,只能用来初始...

    1.默认构造函数:如果类中没有定义构造函数那么程序会默认的为类创建一个无参数构造函数用以对类进行实例化,如果有构造函数的话,那么程序就不会创建默认构造函数

    2静态构造函数,不能访问实例成员,只能用来初始化一些静态字段或者属性,仅在第一次调用类的任何成员时自动执行,不带访问修饰符,不带任何参数,每个类只能有一个静态构造函数,但可以同时还有一个无参实例构造函数,

    3.私有构造函数:把访问的属性设置为私有,那么外部就不能通过new进行实例化访问类中的成员,可以在类的内部声明静态变量属性,进行实例化,通过静态构造方法,对类进行赋值优点如下:

    • 永远不会实例化,因为它仅用作某些静态成员的容器
    • 希望类只能通过调用某个静态方法来实例化(即所谓的对象实例化的类工厂方法)

    构造函数的执行顺序:通常情况下实例化子类的时候,都是先执行父类的构造方法,然后执行子类的构造方法。但是对于子类当中有静态构造方法的时候会先执行子类当中的静态构造方法然后执行父类当中的静态构造方法,之后执行父类的构造方法,最后执行子类的构造方法,而且静态构造方法在程序运行的过程当中都只会执行一次

    事例如下:

    public class SuperClass
    {
        static SuperClass() 
        {
            Console.WriteLine("Super.Static");
        }
        public SuperClass() 
        {
            Console.WriteLine("Super.Instance");
        }
    }
    
    //子类
    public class ChildClass : SuperClass
    {
        static ChildClass() 
        {
            Console.WriteLine("Child.Static");
        }
        public ChildClass() 
        {
            Console.WriteLine("Child.Instance");
        }
    }
    
    //客户程序
    class Program
    {
        static void Main(string[] args)
        {
            ChildClass cc = new ChildClass();
            Console.ReadKey();
        }
    }

    运行结果为:Child.Static

                         Super.static

                         Super.Instance

                         Child.Instance

    注意:在不考了静态构造函数的情况下(因为静态构造仅执行一次,且定义静态构造函数的时候并不多),子类在调用父类的构造函数时,默认情况是调用父类的无参构造函数,如果父类只有带参构造函数,而没有无参构造函数,那么编译时会报错;不过我们可以通过base关键字来指定调用带参构造函数,如下

    public class SuperClass
    {
        public SuperClass(string param)
        {
            Console.WriteLine("Super:" + param);
        }
    }
    
    //子类
    public class ChildClass : SuperClass
    {
        public ChildClass(string param):base(param)
        {
            Console.WriteLine("Child:" + param);
        }
    }
    
    //客户程序
    class Program
    {
        static void Main(string[] args)
        {
            ChildClass cc = new ChildClass("param");
            Console.ReadKey();
        }
    }

    转载自https://www.cnblogs.com/ArtofDesign/p/3603986.html  主要是为了大家一起打好基础

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

    千次阅读 2019-04-03 09:07:15
    拷贝构造函数构造函数不能分开说,他们都是初始化对象的一种方法。但是我们这里用构造函数辅助说明拷贝构造函数,主要说说拷贝构造函数的声明,用途和使用注意事项。 众所周知,构造函数是一个初始化类对象的函数...
  • 一直搞不懂什么是构造函数,为什么要用构造函数构造函数有什么用,逃避这个问题,今天做了简单的总结: 1.构造函数有什么用? 当你需要大批量的写对象的时候,就需要用到构造函数,它可以方便创建多个对象的实例...
  • 1.c++编译器会自动调用构造函数//构造函数(与类名相同) //析构函数:没有参数也没有任何返回类型,被自动调用 #include&lt;iostream&gt; using namespace std; class Test { public: Test();//无参构造函数...
  • C++拷贝构造函数详解

    万次阅读 多人点赞 2011-02-23 13:39:00
    什么是拷贝构造函数 首先对于普通类型的对象来说,它们之间的复制是很简单的,例如: int a = 100; int b = a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量。 下面看一个类对象...
  • 构造函数成员函数的一种,名字与类名相同,可以有参数,不能有返回值(void也不行)。 一个类可以有多个构造函数。 如果定义类时没写构造函数,则编译器生成一个默认的无参构造函数,这个构造函数不做任何操作。...
  • 构造函数 ,是一种特殊的方法 。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中 。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的...
  • 标题:String函数的实现-->主要实现构造函数,拷贝构造函数,析构函数,赋值构造函数。这几个函数是字符串函数最基本的函数,今天也总结一下 #include using namespace std; #include class MyString { private: ...
  • C++中一般创建对象,拷贝或赋值的方式有构造函数,拷贝构造函数,赋值函数这三种方法。 构造函数就是当创建一个类的对象时,它被调用来对类的数据成员进行初始化和分配内存。拷贝构造函数是一种特殊的构造函数,用...
  • C++ 赋值构造函数 复制构造函数

    千次阅读 2018-08-25 15:29:11
    默认构造函数 编译器提供一个不接受任何参数,也不执行任何操作的构造函数,称之为默认构造函数 这是因为创造对象的时候总会调用默认构造函数 Klunk::Klunk() {} //定义 Klunk lunk; //声明 使用默认构造函数 ...
  • 当父类没有定义默认构造函数,定义了了自定义的构造函数时,子类定义构造函数时需要使用父类定义的构造函数,否则编译报错。 父类:没有定义默认构造函数,而是定义了其余的构造函数 子类的构造函数在定义时...
  • c++ 子类构造函数初始化及父类构造初始化

    万次阅读 多人点赞 2018-08-30 15:58:50
    如果在类中没有显式地声明构造函数,那么编译器会自动创建一个默认的构造函数;并且这个默认的构造函数仅仅在没有显式地声明构造函数的情况下才会被创建创建。 构造函数与父类的其它成员(成员变量和成员方法)不同...
  • 构造函数的执行顺序,派生类构造函数 and 父类构造函数 and 成员对象构造函数
  • 默认构造函数构造函数重载

    万次阅读 多人点赞 2017-09-29 08:15:52
    本文主要总结了默认构造函数的相关用法和构造函数重载,旨在能够对平时的项目开发起到一定的夯实基本功的作用,言简意赅,一目了然。首先需要了解构造函数是用来做什么?该类对象被创建时,编译器为对象分配内存空间...
  • c++ 构造函数详解

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

    万次阅读 多人点赞 2018-08-30 22:09:15
    一、拷贝构造函数 转载自:http://www.cnblogs.com/BlueTzar/articles/1223313.html 1、类对象的拷贝  对于普通类型的对象来说,它们之间的复制是很简单的,例如: int a=88; int b=a;   而类对象与普通...
  • C++构造函数之委托构造函数

    千次阅读 多人点赞 2016-10-20 22:16:05
    C++11新标准扩展了构造函数初始值的功能,所以委托构造函数就出现了,一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程,或者说他把自己的一些(或全部)职责委托给了其他构造函数。 1.定义: ...
  • C++默认构造函数

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 215,841
精华内容 86,336
关键字:

构造函数