C ++: formulaire de participation const

---

1. Le paramètre lui-même est const

1. Référence sera initialisé lorsque le programme appelle le paramètre de fonction avec un solide, si le paramètre lui-même est const, supérieure const sera ignorée. Il ne peut pas en déterminant si le paramètre de se distinguer fonction const.

#include <iostream>
using namespace std;
class A
{
public:
    //形参类型是int
    int f(int i)
    {
        cout << "int f(int i)" << endl;
        return 0;
    }
    //形参类型是const int
    int f(const int i)
    {
        cout << "int f(const int i)" << endl;
        return 0;
    }
};

int main()
{
    int i = 1;
    const int ci = 2;
    A a;
    a.f(i);
    a.f(ci);
    return 0;
}

2. Comme l'initialisation de la variable d'initialisation des paramètres. Habituellement, lorsque les pointeurs correspondants de type requis et les références initialisés.

#include <iostream>
using namespace std;
class A
{
public:
    //形参类型是int *
    int f1(int *i)
    {
        cout << "int f1(int *i)" << endl;
        return 0;
    }
    //形参类型是int *const
    int f2(int *const i)
    {
        cout << "int f2(int *const i)" << endl;
        return 0;
    }
    //形参类型是int &
    int f3(int &i)
    {
        cout << "int f3(int &i)" << endl;
        return 0;
    }
};

int main()
{
    int i = 1;
    const int ci = 2;
    A a;
    a.f1(&i);
    a.f1(&ci); //错误，类型不匹配，形参指向int，实参指向const int
    a.f2(&i);
    a.f2(&ci); //错误，类型不匹配，形参指向int，实参指向const int
    a.f3(i);
    a.f3(ci); //错误，类型不匹配，形参引用int，实参指向const int
    return 0;
}

2. paramètre à un const

1. Paramètre pointe vers une fonction du paramètre constant est une fonction de la quantité de points est deux fonctions différentes. Le compilateur peut déterminer si le const argument est déterminé fonctions surchargées.

#include <iostream>
using namespace std;
class A
{
public:
    //形参类型是int*
    int f1(int *i)
    {
        cout << "int f1(int *i)" << endl;
        return 0;
    }
    //形参类型是const int *
    int f1(const int *i)
    {
        cout << "int f1(const int *i)" << endl;
        return 0;
    }

    //形参类型是int &
    int f2(int &i)
    {
        cout << "int f2(int &i)" << endl;
        return 0;
    }
    //形参类型是const int &
    int f2(const int &i)
    {
        cout << "int f2(const int &i)" << endl;
        return 0;
    }
};

int main()
{
    int i = 1;
    const int ci = 2;
    A a;

    a.f1(&i);
    a.f1(&ci);
    cout << "---------------------------------" << endl;

    a.f2(i);
    a.f2(ci);

    return 0;
}

2. Le paramètre est un pointeur ou une référence à la constante, qui est plus une fonction de la gamme d'arguments acceptables. Lorsque l'argument de paramètre est initialisé à un point à un paramètre de pointeur constant est orienté à la quantité acceptable correspondant, le paramètre de référence constante peut être converti en une expression pharmaceutiquement d'un type correspondant.

#include <iostream>
using namespace std;
class A
{
public:
    //形参类型是int*
    int f1(int *i)
    {
        cout << "int f1(int *i)" << endl;
        return 0;
    }
    //形参类型是const int *
    int f2(const int *i)
    {
        cout << "int f2(const int *i)" << endl;
        return 0;
    }

    //形参类型是int &
    int f3(int &i)
    {
        cout << "int f3(int &i)" << endl;
        return 0;
    }
    //形参类型是const int &
    int f4(const int &i)
    {
        cout << "int f4(const int &i)" << endl;
        return 0;
    }
};

int main()
{
    int i = 1;
    const int ci = 2;
    A a;

    //形参指向非常量的函数，只能接受对应的非常量实参
    a.f1(&i);
    a.f1(&ci); //错误，类型不匹配，形参指向int，实参指向const int

    //形参指向常量的函数，可以接受对应的常量或非常量实参
    a.f2(&i);
    a.f2(&ci);
    cout << "---------------------------------" << endl;

    //形参引用非常量的函数，只能接受对应的非常量实参
    a.f3(i);
    a.f3(ci); //错误，类型不匹配，形参引用int，实参是const int
    a.f3(1);   //错误，类型不匹配，形参引用int，实参是字面值类型
    a.f3(1.5); //错误，类型不匹配，形参引用int，实参是字面值类型

    //形参引用常量的函数，可以接受任何能转换的实参
    a.f4(i);
    a.f4(ci);
    a.f4(1);
    a.f4(1.5);
    return 0;
}