标签: const

在看了Herb Sutter的演讲" 你不知道const和mutable"之后,我想知道我是否应该总是将互斥量定义为可变的？如果是的话,我想同样适用于任何同步容器(例如tbb::concurrent_queue)？

一些背景:在他的演讲中,他说const == mutable == thread-safe,并且std::mutex每个定义都是线程安全的.

关于这个话题也有相关的问题,const在C++ 11中是否意味着线程安全.

编辑:

在这里,我发现了一个相关的问题(可能是重复的).不过,它在C++ 11之前被问过.也许这会产生影响.

它是合法的指针到非const转换为指针到常量.

那么为什么将指向非const的指针转换为指向const的指针是不合法的呢？

例如,为什么以下代码是非法的:

char *s1 = 0;
const char *s2 = s1; // OK...
char *a[MAX]; // aka char **
const char **ps = a; // error!

它们是堆栈上的不可变值类型.什么阻止我让他们成为一个常量？

参考文献:

• http://msdn.microsoft.com/en-us/library/ah19swz4(v=vs.71).aspx
• http://msdn.microsoft.com/en-us/library/aa664465(v=vs.71).aspx
• http://msdn.microsoft.com/en-us/library/aa288471(v=vs.71).aspx

(编辑:重大改变,因为前面的例子是有缺陷的,这可能会使一些答案/评论看起来很奇怪)

这可能是一个过于设计,但由于缺少const构造函数,以下是合法的:

class Cheater
{
public:
    Cheater(int avalue) 
       : cheaterPtr(this) //conceptually odd legality in const Cheater ctor
       , value(avalue) 
    {}

    Cheater& getCheaterPtr() const {return *cheaterPtr;}
    int value;

private:
    Cheater * cheaterPtr;
};

int main()
{
    const Cheater cheater(7); //Initialize the value to 7

    cheater.value                 = 4;    //good, illegal
    cheater.getCheaterPtr().value = 4;    //oops, legal

    return 0;
}

似乎提供const构造函数在技术上就像const方法一样容易,并且类似于const重载.

注意:我不是在寻找' Image( const Data & data ) const'而是' const Image( const Data & data) const'

所以:

• 为什么const构造函数在C++中不存在？

这是上下文的一些相关材料:

• http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1995/N0798.htm
• 如何处理const对象中非const引用成员的初始化？ …

在找到并替换重构之后,我最终得到了这个gem:

const class A
{
};

"const class"是什么意思？好像编译好了.

在阅读用C++编写的教程和代码时,我经常偶然发现const关键字.

我看到它使用如下:

const int x = 5;

我知道这意味着它x是一个常量变量,可能存储在只读内存中.

但究竟是什么

void myfunc( const char x );

和

int myfunc( ) const;

？

我回答了关于std :: vector of objects和const-correctness的问题,得到了不应有的 downvote和关于undefined行为的评论.我不同意,因此我有一个问题.

考虑使用const成员的类:

class A { 
public: 
    const int c; // must not be modified! 
    A(int c) : c(c) {} 
    A(const A& copy) : c(copy.c) { }     
    // No assignment operator
}; 

我想要一个赋值运算符,但我不想const_cast在下面的代码中使用其中一个答案:

A& operator=(const A& assign) 
{ 
    *const_cast<int*> (&c)= assign.c;  // very very bad, IMHO, it is undefined behavior
    return *this; 
} 

我的解决方案是

A& operator=(const A& right)  
{  
    if (this == &right) return *this;  
    this->~A() 
    new (this) A(right); …

代码优先:

class A
{
    public:
        ...
        int *foo() const
        {
            return _px;
        }
    private:
        int *_px;
}

成员函数foo返回一个非const的指向private成员的指针_px,我想这会打开修改成员的大门_px,对吧？

是foo一个const成员函数？我应该const在返回类型前添加一个吗？

UPDATE

const-member-function应该保证的是,它不能改变任何数据成员,对吧？

在我的例子中,函数foo没有打开修改class A数据成员_px的大门,而是修改_px指向的内容,所以我的问题是,这是否违反了const函数应该保证的内容？

我经常使用const未修改的局部变量,如下所示:

const float height = person.getHeight();

我认为它可以使编译后的代码更快,允许编译器进行更多优化.或者我错了,编译器可以自己弄清楚局部变量永远不会被修改？

我了解到,如果变量未使用显式声明为可变mut,则变为不可变(在声明后不能更改).那为什么我们const在Rust中有关键字？他们不一样吗？如果没有,它们有何不同？