参数前的 const 与函数名后的 const C++

Question

这样的东西有什么区别

friend Circle copy(const Circle &);

类似的东西

friend Circle copy(Circle&) const;

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

Answer 1

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

另一方面，第二种形式是非法的：只有 成员函数 可以是 const-qualified（而您声明的是全局 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 来自 constant 表示某些东西不可更改但可读。

1. 如果我们用 const 关键字来限定我们的变量，我们以后不能更改它。
   例如
   constint var =25; const 变量必须在声明时初始化。
   var =50; // gives error

2. 如果我们用 const * 来限定我们的指针变量，那么我们不能更改指针本身，但指针的内容是可更改的。
   例如
   int *const ptr = new int;
ptr = new int; //gives error
   // 但是
   *ptr=5445; //allowed

3. 如果我们用 const before * 来限定我们的指针变量，那么我们 可以 更改指针本身，但指针的内容不可更改。
   例如
   intconst* ptr = new int(85);
//or
constint * ptr = new int(85);
ptr = new int; // allowed
   // 但是
   *ptr=5445; // gives error
   

4. 指针和内容都是常量
   例如
   intconst*constptr = new int(85);
//or
const strong>int *constptr = new int(85);
ptr = new int; // not allowed
*ptr=5445; // not allowed
   

---

1. Circle copy(const Circle &);
   这里 const Circle 表示 Circle 的值是只读的，如果我们尝试在函数内部更改 Circle 的值，则会出错。
2. friend Circle copy(Circle&) const;
   这种类型的函数不适用于非成员变量。它用于类或结构。 这里整个函数用 const 关键字限定意味着我们不能改变 object member variable 。 例如
   

    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对象只能调用const函数）。非常量对象也可以调用 const 函数。
• 它必须是“Circle”类的成员函数。

现在考虑下一个：

Circle copy(const Circle &);

而这意味着传递的参数不能在函数内更改。它可能是也可能不是类的成员函数。

注意：可以以这样的方式重载一个函数，以使同一函数具有const 和非常量版本。

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 &);//指函数的常量参数。 can't'改变参数存储的值。

在您的示例中需要删除朋友 圆复制(Circle&) const; //不能改变这个命名为常量成员函数的指针值

Answer 7

friend Circle copy(const Circle &);

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

friend Circle copy(const Circle &)const ; 

该函数是一个不会改变任何类成员值的访问器。通常，函数有多种类型：访问器和修改器。 Accessor：检查但不改变其对象的状态。