Question

这样的事情有什么区别

friend Circle copy(const Circle &);

和类似的东西

friend Circle copy(Circle&) const;

我知道const后，函数被用来告诉编译器这个函数不会尝试更改它被调用的对象，那么另一个呢？

Answer 1

第一种形式意味着绑定到作为Circle函数参数的引用的（状态）copy()对象不会被copy()通过该引用更改。该引用是对const的引用，因此无法通过该引用调用Circle的成员函数，这些函数本身不属于const。

另一方面，第二种形式是非法的：只有成员函数可以是const - 合格的（而您声明的是全局，friend功能）。

当const限定成员函数时，限定引用隐式this参数。换句话说，不允许该函数改变它被调用的对象的状态（隐式this指针指向的对象） - 除了mutable个对象，但那是另一个故事。

用代码说出来：

struct X
{
    void foo() const // <== The implicit "this" pointer is const-qualified!
    {
        _x = 42; // ERROR! The "this" pointer is implicitly const
        _y = 42; // OK (_y is mutable)
    }

    void bar(X& obj) const // <== The implicit "this" pointer is const-qualified!
    {
        obj._x = 42; // OK! obj is a reference to non-const
        _x = 42; // ERROR! The "this" pointer is implicitly const
    }

    void bar(X const& obj) // <== The implicit "this" pointer is NOT const-qualified!
    {
        obj._x = 42; // ERROR! obj is a reference to const
        obj._y = 42; // OK! obj is a reference to const, but _y is mutable
        _x = 42; // OK! The "this" pointer is implicitly non-const
    }

    int _x;
    mutable int _y;
};

Answer 2

C ++类方法具有隐式this参数，该参数在所有显式参数之前出现。所以在类中声明的函数如下：

class C {
  void f(int x);

你可以想象看起来真的像这样：

  void f(C* this, int x);

现在，如果你这样声明：

  void f(int x) const;

就好像你写的那样：

  void f(const C* this, int x);

也就是说，尾随const使this参数为const，这意味着您可以在类类型的const对象上调用该方法，并且该方法无法修改它所在的对象调用（至少不通过正常渠道）。

Answer 3

让我们清除所有与之相关的困惑 const

const 来自恒定，表示某些内容不可更改，但可读。

如果我们使用 const 关键字来限定变量，则以后将无法更改。
例如
const int var =25; const变量必须在声明时进行初始化。
var =50; // gives error
如果我们用 const 来限定指针变量，则 * 之后，我们不能本身更改指针，但是指针的内容可更改。
例如
int * const ptr = new int;
ptr = new int; //gives error
//但是
*ptr=5445; //allowed
如果我们用 const 来限定指针变量，则之前 * ，那么我们可以本身更改指针，但是指针的内容不可更改。
例如
int const * ptr = new int(85);
//or
const int * ptr = new int(85);
ptr = new int; // allowed
//但是
*ptr=5445; // gives error
指针和内容均不变
例如
int const * const ptr = new int(85);
//or
const int * const ptr = new int(85);
ptr = new int; // not allowed
*ptr=5445; // not allowed

Circle copy(const Circle &);
这里的const Circle表示Circle的值是唯一可读的，如果我们尝试在函数内部更改Circle的值，则会产生错误。
friend Circle copy(Circle&) const;
这种类型的函数不适用于非成员变量。它用于类或结构。在这里，整个函数都用const关键字限定，这意味着我们无法更改对象成员变量。例如

    class A{ public :
              int  var;
              void fun1()
                    { var = 50; // allowed
                    } 
              void fun2()const
                       { var=50; //not allowed
                       }
           };

Answer 4

Circle copy(Circle&) const;

使函数const本身。这仅适用于成员函数。

使成员函数const意味着它不能调用任何非const成员函数，也不能更改任何成员变量。它还意味着可以通过类的const对象调用该函数。这个必须是'Circle'类的成员函数。

Circle copy(const Circle &);

虽然这意味着传递的参数不能在函数内改变。这个可能是也可能不是会员功能。

Answer 5

一个参数是函数的另一个参数。

Circle copy(const Circle &);

这意味着传入的参数不能在函数

中更改

Circle copy(Circle&) const;

const限定函数用于成员函数，意味着您无法更改对象本身的数据成员。你发布的例子是荒谬的。

从右向左阅读

如果我们将第一个函数重写为Circle copy(Circle const&);，这意味着同样的事情，很明显从右到左阅读变得有用。 copy是一个函数，它对const对象进行Circle引用，并通过引用返回Circle个对象。

Answer 6

friend Circle copy(const Circle &); //指的是函数的常量参数。不能'改变参数存储的值。

需要在示例中删除好友 圆形副本（Circle＆amp;）const; //无法更改名为常量成员函数

的此poniter值

Answer 7

friend Circle copy(const Circle &);

在函数调用期间不会更改参数的值。

friend Circle copy(const Circle &)const ;

该函数是不更改类成员任何值的访问器。通常，功能类型为：访问器和更改器。访问器：检查但不更改其对象的状态。

在函数名c ++之后的参数vs const之前的const

7 个答案:

从右向左阅读