精华内容
下载资源
问答
  • C++ 析构函数(函数前面有波浪号~)
    千次阅读
    2021-08-09 15:55:53

    什么是析构函数

    析构函数定义类型和构造函数的定义类型差不多, 也是名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。

    构造函数和析构函数对比如下

    #include <iostream>
    #include <string>
    using namespace std;
    
    class Fun_a
    {
    public:
        char *message;
        Fun_a();  //参构造函数
        ~Fun_a(); // 析构函数
        void showCreate();
        void showDelete();
    };
    
    Fun_a::Fun_a()
    {
        message = new char[1024];
    }
    void Fun_a::showCreate()
    {
        cout << "message初始化" << endl;
        cout << message << endl;
    }
    Fun_a::~Fun_a()
    {
        delete message;
    }
    void Fun_a::showDelete()
    {
        cout << "message删除" << endl;
        cout << message << endl;
    }
    
    int main()
    {
        Fun_a a;
        a.showCreate();
        a.showDelete();
        return 0;
    }

    更多相关内容
  • C#构造函数和析构函数 1.构造函数 类的构造函数是类的一个特殊的成员函数,当创建类的新对象时就会执行构造函数。默认的构造函数是没有任何参数,可以为构造函数设置参数,且构造函数的名称必须跟类名一样。 class...

    C#的构造函数与析构函数

    1.构造函数

    类的构造函数是类的一个特殊的成员函数,当创建类的新对象时就会执行构造函数。默认的构造函数是没有任何参数,可以为构造函数设置参数,且构造函数的名称必须跟类名一样。

    创建对象使用的关键字【new】实现过程:
    1、在内存中开辟一块储存空间。
    2、在这块空间上创建对象。
    3、调用对象的析构函数进行对象的初始化。
    

    1.默认使用析构函数。

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student();
            stu1.Name = "小明";
            stu1.StuId = "21002121";
            stu1.ShowStudentInfo();
            Console.ReadKey();
        }
    }
    
    public class Student
    {
        // 默认析构函数,默认
        // public Student()
        // {
        // }
        
    	public Student(string name)
        {
            Name = name;
        }
    
        private string _name;
        public string Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }
    
        private string _stuId;
        public string StuId
        {
            get
            {
                return _stuId;
            }
            set
            {
                _stuId = value;
            }
        }
    
        public void ShowStudentInfo()
        {
            Console.WriteLine("姓名:{0} 学号:{1}", Name, StuId);//输出:姓名:小明 学号:21002121
        }
    }
    

    2.定义多个不同形参的析构函数

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student();
            //调用stu1对象的Student()析构方法
            stu1.ShowStudentInfo();
            //输出:姓名:大一 学号:00000001
    
            Student stu2 = new Student("大二");
            //调用stu2对象的Student(string name)析构方法
            stu2.ShowStudentInfo();
            //输出:姓名:大二 学号:00000002
    
            Student stu3 = new Student("大三", "00000003");
            //调用stu3对象的Student(string name, string stuId)析构方法
            stu3.ShowStudentInfo();
            //输出:姓名:大三 学号:00000003
    
            Console.ReadKey();
        }
    }
    
    public class Student
    {
        //自定义析构函数。
        public Student()
        {
            Name = "大一";
            StuId = "00000001";
        }
    
        //一个参数析构方法
        public Student(string name):this(name, "00000002")
        {
            //为了防止代码的冗余,这里采用this的方法
            //作用:调用构造函数 Student(string name, string stuId)
        }
    
        //两个参数析构方法
        public Student(string name, string stuId)
        {
            Name = name;
            StuId = stuId;
        }
    
        private string _name;
        public string Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }
    
        private string _stuId;
        public string StuId
        {
            get
            {
                return _stuId;
            }
            set
            {
                _stuId = value;
            }
        }
    
        public void ShowStudentInfo()
        {
            Console.WriteLine("姓名:{0} 学号:{1}", Name, StuId);//输出:姓名:小明 学号:21002121
        }
    }
    
    为了防止构造函数出现冗余现象,上述代码采用了【this】关键字解决。
    
    【this】的两个作用:
    1、代表当前类的对象,比如:this.Name = "张三";
    2、在类中根据参数的不同,调用本类的构造函数。如上述代码所示。
    

    2.析构函数

    作用是释放资源 。但是在处理过程中GC机制会进行回收,因此析构函数最大的作用是提前释放资源析构函数不能有参数,不能有任何修饰符而且不能被调用。析构函数与构造函数的标识符不同,特点是在析构函数前面需要加上前缀“~”以示区别。

    class Program
    {
        public Program()
        {
            Console.WriteLine("这是无参数构造函数");
        }
        ~Program()
        {
            Console.WriteLine("这是析构函数");
        }
        static void Main(string[] args)
        {
            Program pro1 = new Program();
        }
    }
    

    运行结果如下:
    这是无参数构造函数
    这是析构函数
    请按任意键继续. . .

    如果系统中没有指定析构函数,那么编译器由GC(Garbage Collection,垃圾回收机制)来决定什么时候进行释放资源

    3.构造函数和析构函数的例子

    为了更好理解构造函数和析构函数的执行顺序,作者编写了以下程序。

    class Program
    {
        private string name;
        public Program()
        {
            Console.WriteLine("这是无参数构造函数");
        }
        public Program(string str)
        {
            name = str;
            Console.WriteLine("这是有参数构造函数");
        }
        ~Program()
        {
            Console.WriteLine("这是" + name + "的析构函数");
        }
        public void SetName(string str)
        {
            name = str;
        }
        public string GetName()
        {
            return name;
        }
        static void Main(string[] args)
        {
            Program pro1 = new Program();
            pro1.SetName("小明");
            Console.WriteLine(pro1.GetName());
            Program pro2 = new Program("小红");
            Console.WriteLine(pro2.GetName());
        }
    }
    

    运行结果如下:
    这是无参数构造函数
    小明
    这是有参数构造函数
    小红
    这是小红的析构函数
    这是小明的析构函数
    请按任意键继续. . .

    当调用完毕,系统就会自动执行析构函数,删除创建好的对象。
    

    引用类型分两步创建,首先在栈上创建一个引用变量,然后在堆上创建对象本生,再把这个内存(也是内存的首地址)赋值给引用变量。如下图所示。所以当删除创建的对象时,实际是按照先进后出的原则进行的(先创建后删除)。所以这就是为什么会先输出“这是小红的析构函数”,再输出“这是小明的析构函数”。

    关于引用类型变量存储的过程

    因为作者精力有限,文章中难免出现一些错漏,敬请广大专家和网友批评、指正。

    展开全文
  • 类构造函数&析构函数

    2019-03-25 16:02:20
    类的构造函数 类的构造函数是类的一种特殊的成员函数,它会在每次创建性的对象时执行 构造函数的名称与类的名称是完全相同的,并且不返回任何类型,也不返回void。构造函数可用于为某些成员变量设置初始值。 下面...

    类的构造函数

    • 类的构造函数是类的一种特殊的成员函数,它会在每次创建性的对象时执行
    • 构造函数的名称与类的名称是完全相同的,并且不返回任何类型,也不返回void。构造函数可用于为某些成员变量设置初始值。

    下面的实例有助于更好地理解构造函数的概念:

    #include <iostream>
    using namespace std;
     
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line();  // 这是构造函数
     
       private:
          double length;
    };
     
    // 成员函数定义,包括构造函数
    Line::Line(void)
    {
        cout << "Object is being created" << endl;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line;//创建对象时会执行构造函数
     
       // 设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }
    
    >>Object is being created
    Length of line : 6

    带参数的构造函数

    默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值,如下面的例子所示:

    #include <iostream>
    using namespace std;
     
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line(double len);  // 这是构造函数
     
       private:
          double length;
    };
     
    // 成员函数定义,包括构造函数
    Line::Line( double len)
    {
        cout << "Object is being created, length = " << len << endl;
        length = len;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line(10.0);
     
       // 获取默认设置的长度
       cout << "Length of line : " << line.getLength() <<endl;
       // 再次设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }
    
    >>Object is being created, length = 10
    Length of line : 10
    Length of line : 6

    使用初始化列表来初始化字段

    Line::Line( double len): length(len)
    {
        cout << "Object is being created, length = " << len << endl;
    }

    上面的语法等同于如下语法:

    Line::Line( double len)
    {
        length = len;
        cout << "Object is being created, length = " << len << endl;
    }

    假设有一个类 C,具有多个字段 length、width、height等需要进行初始化,同理地,您可以使用上面的语法,只需要在不同的字段使用逗号进行分隔,如下所示:

    C::C( double a, double b, double c): length(a), width(b), height(c)
    {
      ....
    }

    类的析构函数

    类的析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。

    析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。

    下面的实例有助于更好地理解析构函数的概念:

    #include <iostream>
    using namespace std;
     
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line();   // 这是构造函数声明
          ~Line();  // 这是析构函数声明
     
       private:
          double length;
    };
     
    // 成员函数定义,包括构造函数
    Line::Line(void)
    {
        cout << "Object is being created" << endl;
    }
    Line::~Line(void)
    {
        cout << "Object is being deleted" << endl;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line;
       // 设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }
    
    >>Object is being created
    Length of line : 6
    Object is being deleted

     

    展开全文
  • 析构函数 类的构造函数 类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量...

    类的构造函数 & 析构函数


    类的构造函数

    类的构造函数是类的一种特殊的成员函数,

    • 它会在每次创建类的新对象时执行。
    • 构造函数的名称类的名称是完全相同的
    • 不会返回任何类型,也不会返回 void
    • 构造函数可用于为某些成员变量设置初始值
    • 注意构造函数没有前缀
    #include <iostream>
    
    using namespace std;
    class Line	// 成员函数定义,包括构造函数
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line();  // 这是构造函数
       private:
          double length;
    };
    Line::Line(void)
    {
        cout << "Object is being created" << endl;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line;
       // 设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }
    

    输出:

    Object is being created
    Length of line : 6
    

    带参数的构造函数

    默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。
    这样在创建对象时就会给对象赋初始值

    #include <iostream>
     
    using namespace std;
     
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line(double len);  // 这是构造函数
     
       private:
          double length;
    };
     
    // 成员函数定义,包括构造函数
    Line::Line( double len)
    {
        cout << "Object is being created, length = " << len << endl;
        length = len;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line(10.0);
     
       // 获取默认设置的长度
       cout << "Length of line : " << line.getLength() <<endl;
       // 再次设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }
    

    输出:

    Object is being created, length = 10
    Length of line : 10
    Length of line : 6
    

    ⭐使用初始化列表来初始化字段

    使用初始化列表来初始化字段:
    初始化数据 length = 输入的形参 len

    Line::Line( double len): length(len)
    {
        cout << "Object is being created, length = " << len << endl;
    }
    

    上面的语法等同于如下语法:

    Line::Line( double len)
    {
        length = len;
        cout << "Object is being created, length = " << len << endl;
    }
    

    假设有一个类 C,具有多个字段 X、Y、Z 等需要进行初始化,同理地,您可以使用上面的语法,只需要在不同的字段使用逗号进行分隔,如下所示:

    C::C( double a, double b, double c): X(a), Y(b), Z(c)
    {
      ....
    }
    

    上述操作等价于

    C::C( double a, double b, double c)
    {
    	X = a; 
    	Y = b;
    	Z = c;
    }
    

    代码示例

    #include <iostream>
    
    using namespace std;
    
    class Line
    {
    public:
        void setLength( double len );
        
        double getLength( void );
        double getWidth( void );
        double getHigh( void );
        double getBox( void );
        Line(double len,double wid,double hig);  // 这是构造函数
    
    private:
        double length;
        double width;
        double high;
        double box;
    };
    
    // 成员函数定义,包括构造函数
    Line::Line( double len,double wid,double hig):length(len),width(wid),high(hig)
    {
        cout << "Object is being created, length = " << len << endl;
    }
    void Line::setLength( double len )
    {
        length = len;
    }
    double Line::getLength( void )
    {
        return length;
    }
    double Line::getWidth(void )
    {
        return width;
    }
    double Line::getHigh()
    {
        return high;
    }
    double Line::getBox()
    {
        return (length*width*high);
    }
    // 程序的主函数
    int main( )
    {
        Line line(8.0,8.0,8.0);
        // 获取默认设置的长度
        cout << "Length of line : " << line.getBox() <<endl;
        // 再次设置长度
        line.setLength(6.0);
        cout << "Length of line : " << line.getBox() <<endl;
        return 0;
    }
    
    

    运行输出

    Object is being created, length = 8
    Length of line : 512
    Length of line : 384
    

    ⭐类的析构函数

    类的析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。

    #include <iostream>
    using namespace std;
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line();   // 这是构造函数声明
          ~Line();  // 这是析构函数声明
     
       private:
          double length;
    };
     
    // 成员函数定义,包括构造函数
    Line::Line(void)
    {
        cout << "Object is being created" << endl;
    }
    Line::~Line(void)
    {
        cout << "Object is being deleted" << endl;
    }
     
    void Line::setLength( double len )
    {
        length = len;
    }
     
    double Line::getLength( void )
    {
        return length;
    }
    // 程序的主函数
    int main( )
    {
       Line line;
     
       // 设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       return 0;
    }
    

    输出:

    Object is being created
    Length of line : 6
    Object is being deleted
    
    展开全文
  • 头歌--C++ 面向对象 - 构造函数与析构函数
  • C++析构函数前加上virtual的原因

    千次阅读 2018-11-19 10:13:05
    class A {  public:  virtual void print(){cout&lt;&lt;"This is A"&lt;&lt;endl;} }; class B : public A {  public:  void print(){cout&...虚函数:指向基类...
  • 类的析构函数

    2020-02-24 18:46:25
    构函数的规则:析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号~作为前缀析构函数的名称与其所属类的名称相同,只是名称前使用了符号”~“ 析构函数没有返回类型,它不会返回任何值,也不能带有...
  • 一、构造函数 为了更好的说明构造函数,首先建立一个简单的日期类 Date.cpp class Date { public: void DatePrint(); void DateSet(int year, int month, int day); private: int m_year; int m_month; int...
  • 文章目录第一关 构造函数 —— 学生信息类任务描述相关知识构造函数初始化成员析构函数编程 学生信息类第二关 对象数组 —— 学生信息表任务描述相关知识构造函数与析构函数的调用编程 学生信息表第三关 静态成员 ...
  • 类的构造函数 类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值...
  • C++ Qt中 类的构造函数 & 析构函数

    千次阅读 2020-10-26 14:12:36
    类的构造函数 类的构造函数是一个特殊的成员函数,它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。 #include <iostream> using ...
  • 构造方法 析构函数 方法重载

    热门讨论 2018-03-25 21:15:11
    构造方法定义:又称构造函数,是类的一个特殊的成员方法格式:[访问修饰符] 类名(){ 构造函数主体部分} 注意:1、 构造函数与类同名2、 没有返回值3、 主体部分包括成员变量的初始化语句 种类:1、 实例...
  • 构造函数与析构函数两者区别

    千次阅读 2020-04-13 22:40:49
    1.构造函数 每次在创建类的新对象的时候执行,构造函数名称与类的名称完全相同,也不会返回任何类型。 (1)构造函数实例 class Line { public: void setLength( double len ); double getLength( void ); Line...
  • C++类的构造函数、析构函数与赋值函数 构造函数、析构函数与赋值函数是每个类最基本的函数。它们太普通以致让人容易麻痹大意,其实这些貌似简单的函数就象没有顶盖的下水道那样危险。  每个类只有一个析构函数和...
  • 析构函数是C++类针对成员变量释放时候执行的函数,在进行析构 class Point { private: int x; int y; public: Point() { std::cout << "/* Point() */" << std::endl; } Point(int x,int y...
  • 构造函数 类的构造函数是类的一种特殊的成员函数。 构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。 构造函数一般是不带参数的,但也可以带参数来赋初值。 使用初始化列表来初始化...
  • 这实际上并没有定义任何的数据,但它定义了类的名称意味着什么,也就是说,类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量成为类的成员。 (1) 类的定义 类的定义是以...
  • 每个类只有一个析构函数和一个赋值函数,但是可以有多个构造函数(包含一个拷贝构造函数,其他的成为普通构造函数)。 下面我们就一起来学习构造函数和析构函数的基本使用。 构造函数 所谓构造函数,就是在对象构造...
  • 目录定义主要特点C++的构造函数定义格式示例1:不带参数的构造函数示例2:带参数的构造函数示例3:使用初始化列表来初始化字段类的析构函数 定义 构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象, 即...
  • 类的构造函数 类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回void。构造函数可用于为某些成员变量设置初始值...
  • 今天总结一下c++的构造函数与析构函数知识点 说在前面1、类和对象 1、类和对象 在说构造函数之前必须先说下C语言中类和对象 一、类的声明 有两种方式声明类,一种使用class来声明,一种使用struct来声明 class 【类...
  • 析构函数

    2020-11-04 09:46:37
    析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。 注意哦,构造函数是有参数的。 构造函数和析构函数在main里面不用特别进行定义。 ~Line() ...
  • 构造函数与析构函数

    2020-04-04 16:37:09
    构造函数与析构函数 文章目录构造函数与析构函数1类的构造函数2类的析构函数3再说构造与析构 1类的构造函数 引例 定义一个类型:Circle, 圆 成员:圆心坐标(x,y),半径radius class Circle { public: int x, y;...
  • C++析构函数的定义和使用

    千次阅读 2013-09-14 11:17:17
    析构函数(destructor)也是一个特殊的成员函数,它的作用与构造函数相反,它的名字是类名的前面加一个“~”符号。 在C++中“~”是位取反运算符,从这点也可以想到:析构函数是与构造函数作用相反的函数。当对象...
  • 析构函数是实现销毁一个类的实例的方法的成员,析构函数不能有参数,不能有任何修饰符而且不能被调用,析构函数与构造函数目的相同,特在析构函数前加前缀“~”以示区别。 构造函数与析构函数虽然是一个类中形式上...
  • 1. 构造函数 构造函数是一种特殊的函数(方法),在根据类创建对象时被调用。构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值。类似于 ...
  • C#类和函数(构造函数、析构函数

    千次阅读 2017-07-25 09:15:34
    这实际上并没有定义任何的数据,但它定义了类的名称意味着什么,也就是说,类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量成为类的成员。 类的定义 类的定义是以...
  • 1、默认构造函数 定义默认构造函数的方法有两种:  (1)如果没有提供任何构造函数,C++将创建默认构造函数。该默认构造函数不接受任何参数,也不执行任何操作。格式如下:  Stonewt::Stonewt(){ } //implicit ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,342
精华内容 4,136
关键字:

析构函数需要什么前缀

友情链接: Hqiaozhengliu.zip