C++语言解读(二)

今天说说函数

  

     函数重载

       什么事函数重载,重载就是用同一个函数名来实现不同的功能,请看例子

 

#include<iostream>
using namespace std;
//函数重载
void func(int);
void func(float);
void func(double);
int main(){

    int a=10;
    float b=3.5;
    double c=3.1616;
    func(a);//重载int
    func(b);//重载float
    func(c);//重载c;
    return 0;
}
void func(int a)
{
    cout<<"a:"<<a<<endl;
}
void func(float b)
{
    cout<<"b:"<<b<<endl;
}
void func(double c)
{
    cout<<"c:"<<c<<endl;
}

 

   说明:重载的意思有点像多态,不同情况下实现不同功能

 

成员函数重载

 

#include<iostream>
using namespace std;
//成员函数重载
class Shu
{
public:
    //成员函数原型
    void print();
    void print(int);
};
//外部实现函数功能
void Shu::print()
{
    cout<<"Hello C++";
}
void Shu::print(int a)
{
    for(int i=0;i<a;i++)
    {
        cout<<"第"<<i<<"次\t"<<"Hello C++"<<endl;
    }
}
int main(){

    int a=10;
    Shu shu;
    shu.print();
    cout<<endl;
    shu.print(a);
    return 0;
}

 

     可以发现成员函数重载道理是一样的.

 

函数的缺省参数

   缺省意思就是可以不输入,如果输入可以覆盖原型的缺省参数。什么意思呢？请看代码

 

#include<iostream>
using namespace std;
//缺省函数参数
void Shu(int=10,int=20);//这里因为是原型，所以可以不用输入参数名
int main(){

    Shu();//不输入参数则默认调用原型缺省参数
    Shu(3,4);//输入参数则会覆盖原型里面的10和20
    return 0;
}
void Shu(int a,int b)
{
    cout<<a*b<<endl;
}

   细心的人或许会有疑问.缺省参数好像实现了函数重载呢。不错，在表面层的确差不多,单实则内里不一.
   什么地方不同了，我认为有2点不同
     1:缺省参数重载的是参数
     2:重载函数是重载的函数方法

 

成员变量的初始化

 成员变量的初始化大约有2种方式，第一种是重载构造函数进行成员变量初始化,请看代码

  

#include<iostream>
using namespace std;
//重载构造函数进行成员变量初始化
class Shu
{
public:
    Shu(int a)
    {
        x=a;//把a的值付给x;
    }
    void print()
    {
        cout<<"输出x的值:"<<x<<endl;
    }
private:
    int x;
};
int main()
{
    Shu su(8);
    su.print();
    return 0;
}

 

    第二种方式和第一种略微不同，请看代码

 

#include<iostream>
using namespace std;
//重载构造函数进行成员变量初始化
class Shu
{
public:
    Shu(int a):x(a)//注意这里写法是:,私有变量名称(值)
    {
        
    }
    void print()
    {
        cout<<"输出x的值:"<<x<<endl;
    }
private:
    int x;
};
int main()
{
    Shu su(20);//注意这里的符号是()
    su.print();
    return 0;
}

 

复制构造函数

   怎么说呢，还是看代码吧

 

#include<iostream>
using namespace std;
//复制构造函数
class Shu
{
public:
    Shu(int a)
    {
        x=a;
    }
    Shu(const Shu& a)//这里添加Shu对象的引用,因为不会修改对象,所以添加Const
    {
        x=a.x;
    }
    void print()
    {
        cout<<x<<endl;
    }
private:
    int x;
};
int main()
{
    Shu a(20);
    Shu b=Shu(a);
    b.print();//测试值有没有被复制过来
    return 0;
}

 

说明:其实对象默认都会提供这么一个构造函数，也就是说删除 Shu(const Shu& a)//这里添加Shu对象的引用,因为不会修改对象,所以添加

Const
 {
  x=a.x;
 }这个构造函数，程序也会执行，大家可以测试一下。复制构造函数一般用在程序执行不同功能时才使用呢

 

 

构造函数和NEW运算符

  

#include<iostream>
using namespace std;
//构造函数和NEW运算符
class Shu
{
public:
    Shu()
    {
        cout<<"构造函数在执行"<<endl;
    }    
};
int main()
{
    Shu a;//这样创建构造函数会自动执行
    Shu* b;//这样构造函数不会执行
    b=new Shu;
    return 0;
}

 

    说明:为什么Shu a会自动执行构造函数呢?前面说明这样创建对象是在栈里面创建的，栈会自动执行构造函数和析构函数。
而new运算符是在堆里面创建的，必须由程序员自己释放对象。。下面就引入了delete和析购函数

 

 

delete和析购函数

 

#include<iostream>
using namespace std;
//构造函数和NEW运算符
class Shu
{
public:
    Shu()
    {
        cout<<"构造函数在执行"<<endl;
    }
    ~Shu()
    {
        cout<<"析构函数在执行"<<endl;
    }
};
int main()
{
    Shu a;//这样创建构造函数会自动执行
    Shu* b;//这样构造函数不会执行
    b=new Shu;
    delete b;//加上这样的语句析构函数才会执行
    return 0;
}

 

调用构造函数进行类型转换

  

#include<iostream>
using namespace std;
//构造函数和NEW运算符
class Shu
{
public:
    Shu(int i)
    {
        x=i;
        cout<<"构造函数在执行"<<endl;
        cout<<i<<endl;
    }
private:
    int x;
};
int main()
{
    Shu su(100);
    su=10000;//这里什么意思呢？这里就是类型自动转换
    //实际上是相当于su=Shu(10000)
    //而Shu(10000)实则又是复制构造函数功能呢。
    return 0;
}

另外感谢一条鱼，从你得博客里我更深入的理解了一些概念！