C++：对象的初始化和构造函数

对象的初始化和构造函数

构造函数：是一种特殊的成员函数，它主要用于为对象分配空间，进行初始化。构造函数
的名字必须与类名相同，它不要用户来调用，而是在建立对象时自动执行的

形式一：
类名 对象名(实参表)；

例如：
class Complex{
 private:
        double real;
        double imag;
 public:
        Complex(double r,double i)
        {
           real = r;
           imag = i;
        }
        double abscomplex()
        {
           double t;
           t = real*real+imag*imag;
           return sqrt(t);
        }
};

// 形式一举例：

 #include<iostream>
 #include<cmath>
 using namespace std;
 class Complex{
 public:
       Complex(double r,double i)             //构造函数
       {
             real = r;
             imag = i;
       }
       double abscomplex()                    //普通函数
       {
             double t;
             t = real*real+imag+imag;
             return sqrt(t);
       }
 private:
       double real;
       double imag;
}A(1.1,2.2);
int main()
{
       //Complex A(1.1,2.2);                   //定义类Complex的对象A时调用构造函数Complex
       cout<<"复数的绝对值是:"<<A.abscomplex()<<endl;
return 0;
}

构造函数
形式二举例：
类名 *指针变量名 = new 类名（实参表）；

/*
 例如：
        int main()
        {
         Complex *pa = new Complex(1.1,2.2);
         cout<<"复数的绝对值是:"<<pa->abscomplex()<<endl;
         cout<<"复数的绝对值是:"<<(*pa).abscomplex()<<endl;
         delete pa;
         return 0;
        }
  构造函数特点：
        1.构造函数的名字必须和类名相同，否则编译程序将把它当作一般函数来处理。
        2.构造函数没有返回值，就是void也不行。
        3.与普通函数一样，构造函数的函数体可写在类体内，也可以写在类体外。
        例如(以下例子省略了inline，为隐式内联函数)：
calss Complex{
 private:
        double real;
        double imag;
 public:
        Complex(double r,duble i);               //声明构造函数原型
        double abscomplex();                     //声明成员函数原型
};
Complex::Complex(double r,double i)              //在类外定义构造函数
{
        real = r;
        imag = i;
}
double Complex::abscomplex()                    //在类外定义成员函数
{
        double t;
        t = real*real+imag*imag;
        return sqrt(t);
}
        4.构造函数的作用主要是用来对对象进行初始化，一般不提倡在构造函数中
          加入与初始化无关的内容。
        5.构造函数一般声明公有成员，但它不需要也不能像其他成员函数那样被显示调用，
          它是在定义对象的同时被自动调用的，而且只执行一次。
        6.在实际应用中，通常需要给每个类定义构造函数。如果没有给类定义构造函数，
          则编译系统自动地生成一个默认的构造函数。
          例如：
                Complex::Complex()
                {}
          注意：这个默认的构造函数不带任何参数，函数体是空的，它只能为对象开辟数据
                成员存储空间，而不能为对象中的数据成员赋初值。
*/

//例3.6  构造函数可以不带参数
#include<iostream>
#include<cmath>
using namespace std;
class Complex{
 private:
        double real;
        double imag;
 public:
        Complex()                    //不带参数的构造函数
        {
            real = 0;
            imag = 0;
        }
        void init(double r,double i) //公有成员函数，作为类的外部接口
        {
            real = r;
            imag = i;
        }
        double abscomplex()
        {
            double t;
            t = real*real+imag*imag;
            return sqrt(t);
        }
};
int main()
{
 Complex A; //定义类Complex的对象A时调用不带参数的构造函数，分别给数据成员real和imag赋初值0
 A.init(1.1,2.2);  //调用公有成员函数init，分别给数据成员real和imag赋值1.1和2.2
 cout<<"复数的绝对值是:"<<A.abscomplex()<<endl;
 return 0;
}