我想知道为什么这种代码可以得到测试数组的大小？我对模板中的语法不熟悉。也许有人可以解释下代码的含义template<typename,size_t>。此外，参考链接也是首选。
#define dimof(array) (sizeof(DimofSizeHelper(array)))
template <typename T, size_t N>
char(&DimofSizeHelper(T(&array)[N]))[N];
void InitDynCalls()
{
char test[20];
size_t n = dimof(test);
printf("%d", n);
}
Scott Meyers 在 Effective Modern C++, Item 30 page 210 中写道，有
无需
static const在类中定义完整的数据成员；仅声明就足够了，
那么示例代码是
class Widget {
public:
static const std::size_t MinVals = 28; // MinVals' declaration;
...
};
... // no defn. for MinVals
std::vector<int> widgetData;
widgetData.reserve(Widget::MinVals); // use of MinVals
我确信这static const std::size_t MinVals = 28;既是声明又是定义，因为它给了一个值MinVals，但评论似乎声称这只是一个声明；第二条评论实际上声称没有定义。代码后面的文字，确实是读
MinVals缺乏定义。
这证实这static const std::size_t MinVals = 28;不是一个定义，所以我有点困惑。
cppreference对我帮助不大（我的粗斜体）：
如果声明
static了整型或枚举类型的数据成员（而不是），则可以使用初始化器对其进行初始化，其中每个表达式都是常量表达式，就在类定义中：constvolatileRun Code Online (Sandbox Code Playgroud)struct X { const static int …
给出以下代码:
struct A { static constexpr int a[3] = {1,2,3}; };
int main () {
int a = A::a[0];
int b [A::a[1]];
}
是A::a必然使用的ODR的int a = A::a[0]？
注意:这个问题代表了休息室辩论的一个不那么闷热/不合逻辑/无穷无尽的版本.
http://coliru.stacked-crooked.com/a/29520ad225ced72d
#include <iostream>
struct S
{
void f()
{
//auto f0 = [] { ++i; }; // error: 'this' was not captured for this lambda function
auto f1 = [this] { ++i; };
auto f2 = [&] { ++i; };
auto f3 = [=] { ++i; };
f1();
f2();
f3();
}
int i = 10;
};
int main()
{
S s;
std::cout << "Before " << s.i << std::endl;
s.f();
std::cout << "After " << s.i << std::endl;
}
Before …我(含糊地)知道如果不 使用模板,则不会实例化模板.例如,以下代码将编译正常,即使T::type没有意义T = int.
template<typename T>
struct A
{
void f() { using type = typename T::type; }
};
A<int> a; //ok
它编译因为f()没有使用,所以它没有被实例化 - 因此T::type仍然没有检查的有效性.其他成员函数g()调用是否无关紧要f().
template<typename T>
struct A
{
void f() { using type = typename T::type; }
void g() { f(); } //Is f() still unused?
};
A<int> a; //ok
这也是罚款.但在这里,我意识到我对"使用"定义的理解模糊.我问:
f()仍未使用？究竟怎么样？我可以清楚地看到它被用在里面g() …
经过16年的中断,我正在重读Scott Meyers的Effective C++.虽然我还没有阅读最新的C++标准,但是我注意到自从第二版Effective C++编写以来C++发生了变化.在他的书的第三版中,Scott Meyers提到即使你有一个空类,意味着没有什么可以初始化或分配,C++编译器仍然会生成至少3个默认函数,即默认构造函数,默认复制构造函数,赋值运算符,可能还有其他一些函数.根据Meyers先生的说法,以下代码将导致产生上述功能.
class Empty {}
Empty E1; // Default constructor.
Empty E2 ( E1 ); // Default copy constructor.
E1 = E2; // Default assignment operator.
考虑到没有什么可以初始化,因为类是空的,C++是否仍然为所述函数生成某种代码？
我有以下代码:
#include <iostream>
#include <tuple>
class T
{
public:
using Names = std::tuple<char const*, char const*>;
static constexpr Names names {"First", "Second"};
};
int main()
{
std::cout << std::get<0>(T::names);
}
由于names是constexpr我期待这个工作.但我收到一个链接器错误:
编译器:
> g++ --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 6.0 (clang-600.0.56) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin14.0.0
Thread model: posix
错误:
> g++ -std=c++1y pl.cpp
Undefined symbols for architecture x86_64:
"T::names", referenced from:
_main in pl-377031.o
ld: symbol(s) not found for architecture x86_64 …因此，我知道在C ++中，如果静态成员是const文字类型，则可以在类内部对其进行初始化，如下所示：
class test{
public:
static constexpr int stc = 1;
private:
int a = 0;
int b = 0;
int c = 0;
};
静态constexpr变量stc可以用在编译器可以直接替换成员值的地方，即
int main () {int array[test::stc];}
但是，如果在不能由编译器直接替换值的上下文中使用：
int main() { const int &cs = test::stc; }
然后编译器（c）生成一个错误
c++ -std=c++11 -pedantic t.cpp -o t
Undefined symbols for architecture x86_64:
"test::stc", referenced from:
_main in t-a8ee2a.o
ld: symbol(s) not found for architecture x86_64
除非静态成员是在类外部定义的，例如：
constexpr int test::stc;
为什么会这样呢？
因此，我们将类定义放在标题中，并且由于 ODR（可能还有更多原因），我们不包括翻译单元而不是标题。此外，由于 ODR，您不应该在标题中添加变量和函数等的定义，因为它可能会违反规则......
但是由于ODR 也适用于类类型（对我来说是类定义），为什么可以不小心将其添加到标题中？
对于具有许多大型和复杂模板实例的库，在我看来，决定是否使用概念的主要考虑因素之一是构建输出的大小是否更小。
使用 SFINAE，我的理解是以下代码将导致模板实例化std::is_function<bar>并std::enable_if<true, bool>包含在构建输出中，增加其大小（尽管对于此示例来说是微不足道的）：
#include <type_traits>
template<typename F,
typename = std::enable_if_t<
std::is_function<F>::value,
bool> = true>
void foo(F& f)
{
// do some stuff with f
}
void g();
int main()
{
foo(g);
return 0;
}
如果使用基于的 C++20 概念std::is_function，显然模板必须被实例化以检查它。但是那个实例化然后写入最终的构建输出吗？这是否因编译器实现而异？
#include <type_traits>
template<typename F>
concept Function = std::is_function<F>::value;
template<Function F>
void foo(F& f)
{
// do some stuff with f
}
//...