用C++构造一个学生类

student stu;

student(); //构造函数

void display()

{

cout<<"名字: "<<name<<" "<<"学号: "<<num<<" "<<"性别: "<<sex<<"年龄: "<<age<<"英语: "<<en<<" "<<"数学: "<<ma<<" "<<"计算机: "<<com<<endl;

}

student (char n[20],int nu, int ag, char se,double e,double m,double c,double av);

~ student ();

void Set();//添加

void Delete();//删除

void Alter();//修改

void List();//显示

void aver();

void ssearch();//查询

// void RearchN();

// void RearchNU();

void staxis(); //排序

void ssave(); //保存

void sload(); //读取

//排序函数

void pnumb();

void peng();

void pmat();

void pcomp();

friend void caozuo(int);

};

void student::aver()

{

double z;

z=en+ma+com;

ave=z/3;

}

student::student()//构造函数

{

strcpy(name, "nomame");

num=0;

sex='M';

age=0;

double en=0;

double ma=0;

double com=0;

double ave=0;

}

student::student (char n[20],int nu, int ag, char se,double e,double m,double c,double av)

{

strcpy(name, n);

num=nu;

sex=se;

age=ag;

en=e;

ma=m;

com=c;

ave=av;

}

student::~student(){};

student s[50];

int i=0;

int j=0;

void student::Set()

{

cout<<"请输入姓名："<<endl;

cin>>name;

cout<<"请输入学号："<<endl;

cin>>num;

cout<<"请输入年龄："<<endl;

cin>>age;

cout<<"请输入性别："<<endl;

cin>>sex;

cout<<"请输入英语成绩："<<endl;

cin>>en;

cout<<"请输入数学成绩："<<endl;

cin>>ma;

cout<<"请输入计算机成绩："<<endl;

cin>>com;

j++;

s[i]=new student(name,num, age, sex,en,ma,com,ave);

i++;

}

void student:: Delete() //(2)删除人员(Delete)

{

cout<<"请输入您要删除的学生姓名："<<endl;

cin>>name;

for(int h=0;h<i;h++)

{

if(strcmp(name,s[h]->name)==0)

{

i--;

s[h]=s[h+1];

h++;

}

else cout<<"您要求删除的对象本来就不存在！请检查输入的正确性！";

}

}

void student::Alter() //(3)修改数据(Alter)

{

cout<<"请输入您要修改的学生的姓名："<<endl;

cin>>name;

for(int h=0;h<i;h++)

{

if(strcmp(name,s[h]->name)==0)

{

int nu;

int ag;

char se;

double e;

double m;

double c;

cout<<"请输入学号: "<<endl;

cin>>nu;

cout<<"请输入年龄："<<endl;

cin>>ag;

cout<<"请输入性别："<<endl;

cin>>se;

cout<<"请输入英语成绩："<<endl;

cin>>e;

cout<<"请输入数学成绩："<<endl;

cin>> m;

cout<<"请输入计算机成绩："<<endl;

cin>>c;

s[h]->num=nu;

s[h]->age=ag;

s[h]->sex=se;

s[h]->en=e;

s[h]->ma=m;

s[h]->com=c;

cout<<"数据修改成功！";

break;

}

if (i == j)

{

cout<<"对不起!您要查询的学生不存在!"<<endl;

break;

}

}

}

void student::List() //(4)显示记录(List)

{

cout<<"本系统所有通讯录的数据如下："<<endl;

if(i==0)

cout<<"管理系统中没有录入数据或者数据已经被删除！"<<endl;

for(int k=0;k<i;k++)

{

s[k]->display();

}

}

void student::ssearch()//查询

{

//system("cls");

cout<<"\n 查询学生信息 \n"<<endl;

cout<<"请输入查询方式："<<endl;

cout<<"1按学号查询"<<endl;

cout<<"2按姓名查询"<<endl;

cout<<"3返回"<<endl;

char c;

cin>>c;

switch (c)

{

case '1':

{ int n;

if(i==0)

{

cout<<"管理系统中没有输入数据！"<<endl; exit(0);;

C++的struct和class差别很小，其实class就是从struct发展出来的。struct定义的结构体在C++中也是一个类，结构体可以有class的任何东西

struct AA

{

public:

int a;

int b;

private:

int a;

int b;

protected:

int GetA() const;

void SetA();

public:

int GetB() const;

AA & operator=(const AA & a);

public:

AA();

AA(const AA & a);

};

可以看到struct和class没有区别，唯一的区别是，如果没有写public、private等，struct缺省是公有成员，class缺省是私有的。

D是错的,应该是在销毁派生类对象时，先调用派生类的析构函数，再调用基类的析构函数

这跟盖房拆房一个道理,盖时肯定要先盖基础(相当于建立时先调用基类),再盖上面(再调用派生类)

拆房时,肯定很从上面拆(先调用派生类的析构函数),再拆下面(再调用基类的析构函数)

其实上面只有简单的解释，上面的调用是因为，若你先调用基类的析构函数，会把派生类正在用的一次资源销毁，因为此时派生类还没有被销毁，所以肯定会出现问题。

不会的。

               c++类的构造函数详解                        

一、 构造函数是干什么的

class Counter

{

public:

         // 类Counter的构造函数

         // 特点：以类名作为函数名，无返回类型

         Counter()

         {

                m_value = 0;

         }

private:

         // 数据成员

         int m_value;

}

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

eg:    Counter c1;

        编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0

故：

        构造函数的作用：初始化对象的数据成员。

二、 构造函数的种类

class Complex 

{         

private :

        double    m_real;

        double    m_imag;

public:

        //    无参数构造函数

        // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做

        // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来

        Complex(void)

        {

             m_real = 00;

             m_imag = 00;

        } 

        //    一般构造函数（也称重载构造函数）

        // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）

        // 例如：你还可以写一个 Complex( int num)的构造函数出来

        // 创建对象时根据传入的参数不同调用不同的构造函数

        Complex(double real, double imag)

        {

             m_real = real;

             m_imag = imag;         

         }

        //    复制构造函数（也称为拷贝构造函数）

        //    复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中

        //    若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述

        Complex(const Complex & c)

        {

                // 将对象c中的数据成员值复制过来

                m_real = cm_real;

                m_img    = cm_img;

        }            

        // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象

        // 例如：下面将根据一个double类型的对象创建了一个Complex对象

        Complex::Complex(double r)

        {

                m_real = r;

                m_imag = 00;

        }

        // 等号运算符重载

        // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建

        // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作

        Complex &operator=( const Complex &rhs )

        {

                // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回

                if ( this == &rhs ) 

                {

                        return this;

                }

                // 复制等号右边的成员到左边的对象中

                this->m_real = rhsm_real;

                this->m_imag = rhsm_imag;

               // 把等号左边的对象再次传出

               // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c

               // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)    

                return this;

        }

};

下面使用上面定义的类对象来说明各个构造函数的用法：

void main()

{

        // 调用了无参构造函数，数据成员初值被赋为00

        Complex c1，c2;

        // 调用一般构造函数，数据成员初值被赋为指定值

        Complex c3(10,25);

        // 也可以使用下面的形式

        Complex c3 = Complex(10,25);

        //    把c3的数据成员的值赋值给c1

        //    由于c1已经事先被创建，故此处不会调用任何构造函数

        //    只会调用 = 号运算符重载函数

        c1 = c3;

        //    调用类型转换构造函数

        //    系统首先调用类型转换构造函数，将52创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1

        c2 = 52;

       // 调用拷贝构造函数( 有下面两种调用方式) 

        Complex c5(c2);

        Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2

  }

如果类没有任何构造函数和拷贝构造函数,那么编译器会默认生成一个默认构造函数

但是如果你的类已经有了自己的带参数的构造函数,或者拷贝构造函数,那么不会帮助你生产默认构造函数

例如

C/C++ code

class abc

{

abc(int i)

}

int main

{

abc a1; // 错误，系统没有默认构造函数

abc a2(2); // 可以正常使用

return 0;

}

最不可行的类是,只有拷贝构造函数,却没有定义任何构造函数的情况,这样的类虽然可以编译通过,却根本无法正常进行对象的事例化