C++|构造、析构、成员(静态、非静态)函数、友元、全局函数

C++是一个多编程范式的编程语言，支持以函数为基本组件的面向过程的编程范式，也支持以类为基本构件的面向对象的编程范式。由此，其支持的函数类型也可以区分为与类相关的构造、析构、成员（静态、非静态）函数，以及全局函数（内部链接或外部链接），同时也支持友元函数。（与Java要求所有代码写在类内，所有数据和代码要隶属于不同的类不同，C++可以定义全局函数和全局变量（外部变量））

直接看实例和注释：

/* 构造、析构、成员（静态、非静态）函数、友元、全局函数
non_static member function: 有隐藏的this指针(指向对象数据成员的起始地址)
    static member function: 没有this指针(所以不能访问non_static的成员数据)，有类作用域
           friend function: 有权限可以额外访问声明其为友元的类的私有成员
    statci global function: internal linkage,otherwise, external linkage
               constructor: initializing data member;
                destructor: free or close resource
*/
#include <stdio.h>
class Demo
{
public:
    Demo(double a,double b):ci(a)// 构造函数
    {
        pv = b;
        de = new double(99.99);
    }

    friend double ff(Demo &d);  // 友元函数声明

    static double sf(double r)  // static member function，没有隐含的this指针
    {
        return r*r*PI;
        //return r*r*pv;        // static member function can't access non-static member
    }

    double mf(double r)         // non_static member function，隐含this指针
    {
        return 2*r*pv+PI-PI;
    }

    ~Demo(){delete de;}         // 析构函数，如果有资源占用需要释放，如free()、fclose()

    Demo(const Demo& d):ci(d.ci) // 复制构造函数
    {
        pv = d.pv;
        de = new double(99.98);
    }

    Demo& operator=(const Demo& d) // 赋值运算符重载
    {
        if(this != &d)
        {
            pv = d.pv;
            delete de;
            de = new double(99.89);
        }
        return *this;
    }

    double getci() const
    {
        return ci;
    }

    Demo operator++(int)
    {
        Demo d = *this;
        pv = pv + 1;
        return d;
    }

    static double PI;// 静态数据成员在类外初始化，表明其仅一份，与对象无关，但可为对象使用
private:
    double pv;
    const double ci;    // const成员需使用初始化列表初始化
    double *de;                 // point to heap memory block
};

double Demo::PI=3.1415926;      // static成员类外初始化 

double ff(Demo &d)              // 友元函数定义
{
    Demo e(5,6);
    return d.pv+e.pv;
}

static double gf(Demo d)         // 全局函数定义，static表示internal linkage
//static double gf(Demo &d)      // 对于有指针成员的类，如果没有复制构造函数，则不能是值传递
{
    
    static double sv = d.mf(3);
    sv += 2*2*d.PI;// sv += d.pv // error，static function can't access non-static member
    return sv;
}

const int g_var = 89;            // 默认为internal linkage

int main()
{
    Demo d(4,5);
    double sum = g_var;
    sum += d.sf(3);
    sum += Demo::sf(3);
    sum += d.mf(3);
    sum += ff(d);
    sum += gf(d);
    printf("%lf\n",sum);
    Demo e = d;
    e++;
    printf("%lf\n",e.getci());
    getchar();
    return 0;
}

类是对数据的再次分类或数据类型的自定义，是一种不同于面向过程的代码组织方式和编程思想，是对数据和函数的封装，提供了访问控制的安全机制，也提供了类名的命名空间和作用域。同时，也为非静态成员函数提供了隐含的this指针。当然，类的继承性和多态代码重用和扩展的一种重要手段。

－End－