121

像这样的东西有什么区别

friend Circle copy(const Circle &);

和这样的东西

friend Circle copy(Circle&) const;

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

4

7 回答 7

249

第一种形式意味着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;
};
于 2013-04-14T12:36:51.830 回答
88

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 对象上调用该方法，并且该方法不能修改调用它的对象（至少，不能通过正常通道）。

于 2013-04-14T12:38:58.347 回答
15

让我们清除所有与 const

const来自常数意味着某些东西是不可改变但可读的。

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

  2. 如果我们用after限定我们的指针变量，那么我们不能更改指针本身，但指针的内容是可变的。 例如 // 但是const *

    int *const ptr = new int;
    ptr = new int; //gives error

    *ptr=5445; //allowed

  3. 如果我们用before限定我们的指针变量，那么我们可以更改指针本身，但指针的内容是不可更改的。 例如 // 但是const *

    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
    constint *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 关键字限定，这意味着我们不能更改对象成员变量。例如
    class A{ public :
              int  var;
              void fun1()
                    { var = 50; // allowed
                    } 
              void fun2()const
                       { var=50; //not allowed
                       }
           };
于 2020-07-03T07:20:10.500 回答
12 
Circle copy(Circle&) const;

使函数const本身。这只能用于类/结构的成员函数。

制作成员函数const意味着

  • 它不能调用任何非常量成员函数
  • 它不能改变任何成员变量。
  • 它可以被一个const对象调用（const对象只能调用const函数）。非常量对象也可以调用const函数。
  • 它必须是“ Circle ”类的成员函数。

现在考虑下一个：

Circle copy(const Circle &);

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

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

于 2013-04-14T12:49:29.487 回答
4

一个是指参数，另一个是函数。

Circle copy(const Circle &);

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

Circle copy(Circle&) const;

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

从右到左阅读

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

于 2013-04-14T12:35:52.520 回答
0

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

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

于 2013-04-14T12:38:54.030 回答
0 
friend Circle copy(const Circle &);

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

friend Circle copy(const Circle &)const ;

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

于 2019-02-01T22:40:10.723 回答