精华内容
下载资源
问答
  • 学生类的构造与析构
    2021-12-23 22:23:09

    一、类对象成员的构造

            1、先构造成员

           2、再构造自身(调用构造函数)

    二、派生类构造函数

            派生类可能有多个基类,也可能包括多个成员对象,在创建派生类对象时,派生类的构造函数除了要负责本类成员的初始化外,还要调用基类和成员对象的构造函数,并向它们传递参数,以完成基类子对象和成员对象的建立和初始化。

    1、派生类只能采用构造函数初始化列表的方式向基类或成员对象的构造函数传递参数,形式如下:

    派生类构造函数名(参数表):基类构造函数名(参数表),成员对象名1(参数表),…

    {

        //……

    }

    三、构造函数和析构函数调用次序

    1、派生类对象的构造

    - 先构造基类

    - 再构造成员

    - 最后构造自身(调用构造函数)

    基类构造顺序由派生层次决定:**最远的基类最先构造**

    成员构造顺序和定义顺序符合

    析构函数的析构顺序与构造相反

    更多相关内容
  • 定义一个学生类Student,使得main()函数能够得到指定的输出结果 main()函数如下: /* 请在这里填写答案 */ int main() {Student stud1(10010,"Wang_li",'f'); stud1.display(); Student stud2(10011,"Zhang_fun...

    类定义:

    定义一个学生类Student,使得main()函数能够得到指定的输出结果
    

    main()函数如下:

    /* 请在这里填写答案 */
    int main()
      {Student stud1(10010,"Wang_li",'f');
       stud1.display();
       Student stud2(10011,"Zhang_fun",'m');
       stud2.display();
       return 0;
    }
    

    输入样例:

    输出样例:
    在这里给出相应的输出。例如:

    Constructor called.
    num:10010
    name:Wang_li
    sex:f
    
    Constructor called.
    num:10011
    name:Zhang_fun
    sex:m
    
    Destructor called.
    Destructor called.
    

    答案如下:

    #include <iostream>
    #include<cstring>
    using namespace std;
    class Student
    {
    	private:
    		int NUMBER;
    		string NAME;
    		char SEX;
    	public:
    		Student(int number,string name ,char sex)
    		{
    			cout<<"Constructor called."<<endl;
    			NUMBER=number;
                NAME=name;
                SEX=sex;
    		}
    		void display()
    		{
    			cout<<"num:"<<NUMBER<<endl;
    			cout<<"name:"<<NAME<<endl;
    			cout<<"sex:"<<SEX<<endl;
                printf("\n");//没办法了强行换行
            }
    		~Student()
    		{
                
    			cout<<"Destructor called."<<endl;
    		}
    };
    /* 请在这里填写答案 */
    // int main()
    //   {Student stud1(10010,"Wang_li",'f');
    //    stud1.display();
    //    Student stud2(10011,"Zhang_fun",'m');
    //    stud2.display();
    //    return 0;
    // }
    
    

    在这里插入图片描述

    今天还要继续加油!!!!!

    展开全文
  • 构造析构

    千次阅读 2015-03-27 08:28:44
    Java中得finalize方法不等同于C++的析构,只有在内存资源不足的时候才会被执行。另外如果是通过Java的方法正常new出来的对象是不需要在finalize中去释放的。当使用本地方法即C或C++的内存分配的时候,就需要在...

    基本类型重载时会自动将小类型提升到int类型

    如下的程序

    public class Test
    {
    	public static void main(String args[])
    	{
    		Test t = new Test();
    		t.f1(3); //默认提升为int
    		t.f1('a');//调用的还是char
    		t.f1((char)3);//进行了显示的转换,所以会调用char的函数
    	}
    	
    	void f1(char x)
    	{
    		System.out.println("char");
    	}
    	
    	void f1(byte x)
    	{
    		System.out.println("byte");
    	}
    	
    	void f1(short x)
    	{
    		System.out.println("short");
    	}
    	void f1(int x)
    	{
    		System.out.println("int");
    	}
    	
    	void f1(long x)
    	{
    		System.out.println("long");
    	}
    }

    为什么不能通过返回值来区别重载

    如果是通过
    int ret = func()的形式来调用的,则编译器知道需要调用返回int的函数
    但是如果是没有使用返回值,直接是
    func()来调用的那么就无法识别需要调用那个函数。

    默认构造器

    当用户自己定义了构造函数的时候,编译器将不会提供默认构造函数。

    this的两种用法

    代表当前对象,当做构造函数来用
    另外,由于构造函数必须在其他构造函数第一句来调用,所以一个函数中不能同时调用两个构造函数(总有一个放在第二句的)。
    public class Test
    {
    	String s = "member var";
    	public static void main(String args[])
    	{
    		Test t = new Test("TT");
    	}
    	
    	Test()
    	{
    		System.out.println("constructor");
    	}
    	
    	Test(String s)
    	{
    		//Test(); 构造函数的调用必须用this
    		this();
    		System.out.println(s);
    		System.out.println(this.s); //this的第二种用法,代表当前对象
    		// this(); 调用构造函数必须在第一行中调用
    	}
    	
    	Test(int third)
    	{
    		this();
    		this("hello"); //由于构造函数必须在其他构造函数中第一句调用,所以不能同时调用两个构造函数
    	}
    	
    	void func()
    	{
    		//this(); 不能在非构造函数中调用构造函数
    	}
    }

    Finalize方法

    Java中得finalize方法不等同于C++的析构,只有在内存资源不足的时候才会被执行。另外如果是通过Java的方法正常new出来的对象是不需要在finalize中去释放的。当使用本地方法即C或C++的内存分配的时候,就需要在finalize中释放这些内存。

    由于finalize的父类中被定义为protected类型的,所以在定义finalize的时候必须定义为protected的,或者public的。

    强制系统进行垃圾回收

    System.gc()

    关于初始化

    函数的局部变量必须在使用前进行初始化。
    但是类的成员变量,系统会进行默认初始化。

    所以如果要对成员变量进行初始化就直接在定义的时候进行,如果要是在构造函数中进行初始化,则默认的初始化了一次,在构造中又进行了一次就出现了浪费的情况。
    之所以在构造函数初始化的原因:并不是所有的构造函数中都会对成员变量进行初始化,在构造之前进行初始化一次能够保证所有的对象在创建时都会被初始化。
    如下例子,成员变量的初始化总是出现在构造函数之前。
    class Window{
    	Window(int marker) {
    		System.out.println("window("+marker+")");
    	}
    }
    
    class House{
    	Window w1 = new Window(1);
    	House()
    	{
    		System.out.println("House()");
    		w3 = new Window(33);
    	}
    	Window w2 = new Window(2);
    	void f(){ System.out.println("f()");}
    	Window w3 = new Window(3); //变量会先于构造函数初始化
    }
    
    public class Test{
    	public static void  main(String[] args)
    	{
    		House s = new House();
    		s.f();
    	}
    }

    <完>

    展开全文
  • C++设计一个学生类,包括学号、姓名、性别、计算学生的总成绩的成员函数以及构造函数和析构函数。一直搞不懂构造函数怎么调用,和析构函数有什么用。非常感谢
  • 1.的构成 class 类名 { public: 公有数据成员; 公有成员函数; protected: ...不能在中给数据成员赋值,需要在构造函数中赋值。 2.成员函数的声明 在中给出函数声明: 返回类型 成员函数(参数列表)

    1.类的构成

    class  类名 {
    public:
      公有数据成员;
      公有成员函数;
    protected:
      保护数据成员;
      保护成员函数;
    private:
      私有数据成员;
      私有成员函数;
     };
    

    private只能本类的成员函数访问

    protected可以由本类或者派生类访问

    public是任意函数能访问

    private出现在程序的开始时,关键词可以省略。

    不能在类中给数据成员赋值,需要在构造函数中赋值。

    2.成员函数的声明

    在类中给出函数声明:

    返回类型  成员函数(参数列表);
    

    在类外给出函数定义:

    返回类型  类名∷成员函数名(参数表)
      {
           // 函数体
      }
    

    内联函数:函数体放在类中。

    外联函数:函数头放在类中,定义在类外。

    内联函数性能优于外联函数,在外联函数前面加上inline可以将外联函数转化为内联函数。

    一般较短的定义为内联函数比较合适,较长的定义为一般函数。

    3.对象的定义和使用

    声明对象

    可以在声明类的同时定义,也可以在声明后定义。

    class  Coord { 
        public:
            void setCoord(int,int);
            int getx();
            int gety();
        private:
            int  x,y;
        }   op1,op2; 
    
    class  Coord { 
         //…
      }; 
         // …
     main()
     {
       Coord  op1,op2;
         // …
      }
    

    访问对象的方法

    对象名.数据成员名

    对象名.成员函数名

    其实是一种缩写:

    对象名.类名::成员名

    如果定义指向对象的指针,使用->访问成员

    对象赋值

    相同类型变量可以互相赋值,赋值方法为逐位拷贝。

    如果类中存在指针,可能会出现错误。

    4.构造函数与析构函数

    构造函数作用

    初始化成员变量,

    没有返回类型,

    可以没有参数

    必须和类同名,不需要用户调用。

    class 类名
    { public:
    	类名(形参表);		//构造函数的原型
    	//类的其它成员
    };
    类名::类名(形参表)	//构造函数的实现
    {
    	//函数体
    } 
    

    构造函数初始化参数的方式

    在函数体内赋值

    或者使用初始化列表的方式

    类名::构造函数名(参数表):(成员初始化表)
    {
        // 构造函数体
    }
    

    初始成员列表的形式为:

    数据成员名1(初始值1),数据成员名2(初始值2),…… 
    

    拷贝构造函数

    使用一个已经存在的对象初始化新对象

    如果使用等号赋值,系统自动调用拷贝构造函数。

    拷贝构造函数也是构造函数,只有一个参数,是同类对象的引用。

    可以对拷贝构造函数进行自定义:

    class 类名
    {  public :
           类名(形参);//构造函数
           类名(类名 &对象名);//拷贝构造函数
               ...
    };
    类名:: 类名(类名 &对象名)//拷贝构造函数的实现
    {    函数体    }
    

    拷贝构造函数的使用:

    Coord p2(p1);    // 用对象p1初始化对象p2, 
    Coord p3=p1;    // 用对象p1初始化对象p3, 
    

    缺省拷贝构造函数:如果没有定义拷贝构造函数,C++自动使用逐个成员拷贝的方式。

    浅拷贝:默认拷贝函数的方式,逐一拷贝数据成员。如果数据成员出现指针会产生错误。

    深拷贝:自定义拷贝,将指针所指的内存进行拷贝

    类组合构造函数

    类组合指的是类的成员是一个类的对象。

    类组合构造函数必须对本类中的基本类型成员数据赋值,也要对对象成员初始化。

    类名::类名(对象成员所需的形参,本类成员形参)
           :对象1(参数),对象2(参数)......
    {  本类初始化  }
    

    先调用内嵌对象的构造函数,然后调用本类的构造函数。

    析构函数

    与类名称相同,多一个~,不能被重载,无函数值,没有参数,没有返回值

    生命周期结束时,系统自动调用。

    调用顺序

    构造函数1->构造函数2->构造函数3->结构函数3->解构函数2->解构函数1

    向前引用声明

    如果需要在类声明之前引用该类,需要向前引用声明。

    要求在完整声明其之前不能声明该类的对象。可以声明该类的指针。但是不能使用该类的方法或者成员变量。

    class B;  //前向引用声明
    class A
    {  public:
          void f(B b);
    };
    class B
    {  public:
          void g(A a);
    };
    
    展开全文
  • 构造与析构 C++面向对象编程过程中消息传递最重要也是最基础的内容。数据的封装抽象都是通过来实现。 在C语言中有结构体表示数据类型,C++继承了结构体并且归为特殊形式的。结构体只是...
  • 目录 1 构造函数的定义 ...8 构造函数和析构函数执行顺序 1 构造函数 1.1 对象如何初始化 如果的数据成员是public的权限,可以在定义对象时初始化。 class Time { public: int hour; ...
  • 学生类构造函数

    2017-11-22 14:18:11
    1. 定义一个学生类Student,包括:属性学号,姓名,性别,年龄,方法包括构造方法初始化变量;显示学号方法、显示姓名方法、显示性别方法、显示年龄方法、修改年龄方法。 2. 定义一个测试StudentTest创建两个学生...
  • C++构造与析构-10

    2017-09-24 23:24:00
    一。对象的初始化 ...为每个偶读提供一个public的initialize函数  b。对象创建后立即调用initialize函数进行初始化 #include<stdio.h> class Test { private: int i; public:...
  • 对象构造析构遵循规则如下:派生构造,先构造所有基类(基类构造的顺序为其声明的顺序),然后才构造当前派生;派生如存在成员对象,成员对象会先被构造,然后才运行构造函数构造当前派生
  • C++:构造函数和析构函数 C构造函数和析构函数 构造函数 声明和定义 引用参数与构造函数 使用构造函数定义对象 默认构造函数 析构函数 声明和定义 析构函数的执行时机 const成员函数 ...
  • 构造析构基础

    2016-11-18 13:25:59
    #define _CRT_SECURE_NO_WARNINGS #include using namespace std; class Test { ... Test() //无参数 构造函数 { a = 10; //作用完成对属性的初始化工作 p = (char *)malloc(100);
  • C++类构造函数和析构函数详细刨析,高细腻度讲解

    多人点赞 热门讨论 2022-01-17 11:15:56
    1、认识构造函数 1.1构造函数的认识 构造函数是C++中一种特殊的成员函数,构造函数的作用不是开辟空间创建变量,而是对实例化的对象进行初始化。下面让我来看一下构造函数...1.2以学生类为例,来看一下我们自己定义的
  • 先看下面一段代码 person { person() { //无参构造函数 ...构造函数,就是在函数被创建一个对象的时候会调用它构造方法,只会调用一次并且是其中一种的构造方法; 1:调用无参构造 在栈中创建: person per...
  • 构造 class Per { char p_name; int p_age; public: //构造 Per() {}; Per(int age) { p_age = age; } Per(char name, int age) { p_name = name; p_age = age; } //拷贝构造函数 Per(const Per&...
  • 1、C++中的可以定义类名相同的特殊成员函数,这种类名相同的成员函数叫做构造函数。 这句话中我们可以提前出两个信息:1构造函数的函数名可以和类名相同 ;2构造函数是的成员 。其次,构造函数在定义时可以...
  • 简单定义 #include <iostream> #include <string> using namespace std; class Student { public: int uid; char *name; int age; public: void set(int id, char *name, int age) { this-&...
  • 实验七 类构造与静态成员函数C++编程题:A. 三角形(构造与析构),B. Equation(类与对象+构造),C. 图书借阅(对象数组+构造),D. 手机服务(构造+拷贝构造+堆),E. 最高成绩(静态成员)
  • 1.简单的派生构造函数 简单的派生只有一个基类,而且只有一级派生。 简单派生构造函数一般形式为: 派生类构造函数名(总参数列表):基类名(参数列表) { 派生中新增成员变量初始化语句 } 下面通过一...
  • 构造函数 —— 学生信息

    千次阅读 2020-10-26 12:41:17
    本关任务:设计一个带有构造函数和析构函数的学生类。 二、相关知识 构造函数、析构函数赋值函数是每个最基本的函数。他们太普通以致让人容易麻痹大意,其实这些貌似简单的函数在使用时要特别注意以免造成不必要...
  • 【c++】构造函数和析构函数

    千次阅读 多人点赞 2018-05-06 19:34:45
    【c++】构造函数和析构函数 一.构造函数 二.构造函数的重载 三.析构函数参考:《c++从入门到精通》 人民邮电出版社 一.构造函数 构造函数是和类名相同的一个函数,它的作用是实现对象的初始化。当对象被...
  • 和对象--构造函数和析构函数1 构造函数1.1 定义1.2 调用1.3 特点2 析构函数1.1 定义2.2 调用2.3 特点3 构造函数的分类及调用 ★ 1 构造函数 1.1 定义 C++中的可以定义类名相同的特殊成员函数,这种类名相同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,755
精华内容 2,302
关键字:

学生类的构造与析构