小编Rob*_*Rob的帖子

我一直想知道这一点 - 为什么你不能在switch语句中的case标签之后声明变量？在C++中,您可以在任何地方声明变量(并且声明它们接近第一次使用显然是一件好事)但是以下仍然不起作用:

switch (val)  
{  
case VAL:  
  // This won't work
  int newVal = 42;  
  break;
case ANOTHER_VAL:  
  ...
  break;
}  

以上给出了以下错误(MSC):

'case'标签跳过'newVal'的初始化

这似乎也是其他语言的限制.为什么会出现这样的问题？

前段时间我遇到了一些用mutable关键字标记类的成员变量的代码.据我所知,它只是允许您修改const方法中的变量:

class Foo  
{  
private:  
    mutable bool done_;  
public:  
    void doSomething() const { ...; done_ = true; }  
};

这是这个关键字的唯一用途,还是有更多的东西比它的眼睛？我已经在一个类中使用了这个技术,标记为一个boost::mutex可变的允许const函数为了线程安全的原因锁定它,但是,说实话,这感觉有点像黑客.

我有一些模板代码,我宁愿存储在CPP文件中而不是标题中的内联.我知道只要您知道将使用哪些模板类型,就可以完成此操作.例如:

.h文件

class foo
{
public:
    template <typename T>
    void do(const T& t);
};

.cpp文件

template <typename T>
void foo::do(const T& t)
{
    // Do something with t
}

template void foo::do<int>(const int&);
template void foo::do<std::string>(const std::string&);

注意最后两行--foo :: do模板函数仅用于int和std :: strings,因此这些定义意味着应用程序将链接.

我的问题是 - 这是一个讨厌的黑客还是会与其他编译器/链接器一起使用？我目前只在VS2008上使用此代码,但是想要移植到其他环境.

我注意到现代的C和C++代码似乎size_t代替int/ unsigned int几乎无处不在 - 从C字符串函数的参数到STL.我很好奇这个原因及其带来的好处.

你走多远const？您是否只是const在必要时制作功能,或者您是否全力以赴并在任何地方使用它？例如,想象一个简单的mutator,它接受一个布尔参数:

void SetValue(const bool b) { my_val_ = b; }

这const实际上有用吗？我个人选择广泛使用它,包括参数,但在这种情况下,我想知道它是否值得？

我还惊讶地发现你可以省略const函数声明中的参数,但可以将它包含在函数定义中,例如:

.h文件

void func(int n, long l);

.cpp文件

void func(const int n, const long l)

是否有一个原因？这对我来说似乎有点不寻常.

我非常喜欢让编译器为你做尽可能多的工作.在编写一个简单的类时,编译器可以为"free"提供以下内容:

• 默认(空)构造函数
• 复制构造函数
• 析构函数
• 赋值运算符(operator=)

但它似乎无法给你任何比较运算符 - 如operator==或operator!=.例如:

class foo
{
public:
    std::string str_;
    int n_;
};

foo f1;        // Works
foo f2(f1);    // Works
foo f3;
f3 = f2;       // Works

if (f3 == f2)  // Fails
{ }

if (f3 != f2)  // Fails
{ }

有这么好的理由吗？为什么执行逐个成员比较会成为问题？显然,如果类分配内存然后你要小心,但对于一个简单的类肯定编译器可以为你做这个？

令我惊讶的是,我刚刚发现MS Visual Studio 2003向上缺少C99 stdint.h.我确定他们有他们的理由,但有谁知道我可以在哪里下载副本？如果没有这个头文件,我就没有uint32_t等有用类型的定义.

拥有使用默认参数的类构造函数是一种好习惯,还是应该使用单独的重载构造函数？例如:

// Use this...
class foo  
{
private:
    std::string name_;
    unsigned int age_;
public:
    foo(const std::string& name = "", const unsigned int age = 0) :
        name_(name),
        age_(age)
    {
        ...
    }
};

// Or this?
class foo  
{
private:
    std::string name_;
    unsigned int age_;
public:
    foo() :
    name_(""),
    age_(0)
{
}

foo(const std::string& name, const unsigned int age) :
        name_(name),
        age_(age)
    {
        ...
    }
};

这两个版本似乎都有用,例如:

foo f1;
foo f2("Name", 30);

您更喜欢或推荐哪种风格？为什么？

当重构一些时,#defines我遇到了类似于C++头文件中的以下声明:

static const unsigned int VAL = 42;
const unsigned int ANOTHER_VAL = 37;

问题是,静态会产生什么不同,如果有的话？请注意,由于经典#ifndef HEADER #define HEADER #endif技巧(如果重要),不可能多次包含标题.

VAL如果标题包含在多个源文件中,静态是否只创建了一个副本？

虽然重构了一些代码,但我遇到了一些返回std :: string的getter方法.像这样的东西例如:

class foo
{
private:
    std::string name_;
public:
    std::string name()
    {
        return name_;
    }
};

当然吸气者会更好地回归const std::string&？当前方法返回的副本效率不高.会返回一个const引用会导致任何问题吗？