为什么某些运算符只能作为成员函数重载,其他作为非成员"自由"函数,其余的作为两者？
这些背后的理由是什么？
如何记住哪些运营商可以超载(成员,免费或两者)？
例如:
class Base {
virtual void my_function() = 0;
};
class Derived : Base {
void my_function() override;
};
从我读到的,override关键字用于确保我们在我们覆盖的函数中具有正确的签名,并且它似乎是它的唯一用途.
但是,在纯虚函数的情况下,如果我们在Derived类(或Base类中使用不正确的签名,取决于如何看待事物)中使用不正确的签名,编译器将抛出错误.那么,在声明override结束时添加是否有任何意义Derived::my_function()？
我们可以将可变参数模板参数限制为某种类型吗？即,实现类似的东西(当然不是真正的C++):
struct X {};
auto foo(X... args)
在这里,我的目的是拥有一个接受可变数量X参数的函数.
我们最接近的是:
template <class... Args>
auto foo(Args... args)
但是这接受任何类型的参数.
在当前草案的 17.6.4.2.1/1和17.6.4.2.1/2中,标准限制是针对用户注入的专业化namespace std.
如果C++程序向命名空间std或命名空间std中的命名空间添加声明或定义,则它是未定义的,除非另有说明.只有当声明取决于用户定义的类型 并且特化符合原始模板的标准库要求且未明确禁止时,程序才可以将任何标准库模板的模板特化添加到命名空间std .
我无法在标准中找到定义用户定义类型的短语.
我听说声称一个选项是一个类型,是不是std::is_fundamental是一个用户定义类型,在这种情况下std::vector<int>将是一个用户定义的类型.
另一种答案是用户定义的类型是用户定义的类型.由于用户未定义std::vector<int>,并且std::vector<int>不依赖于用户定义的任何类型,std::vector<int>因此不是用户定义的类型.
一个实际的问题,这影响是"你可以注入一个专业化的std::hash为std::tuple<Ts...>成namespace std如果能够这样做在一定程度上方便-另一种方法是创建另一个命名空间,我们递归构建我们的哈希std::tuple(可能还有其他类型的std没有hash支持),当且仅当我们无法在该命名空间中找到哈希时,我们才会重新开始std.
但是,如果这是合法的,那么如果标准hash为std::tupleto 添加了特殊化namespace std,那么专用它的代码就会被破坏,从而创建一个不再添加此类特化的理由.
虽然我所说的std::vector<int>是一个具体的例子,但我试图询问定义的类型std是否是用户定义的类型.次要问题是,就算没有,也许std::tuple<int>成为一个用户定义类型用户使用时(这得到滑:那么,什么会发生,如果里面的东西std定义std::tuple<int>,你局部专门hash为 …
什么是外联虚拟方法以及它为什么会影响链接时间？
http://llvm.org/docs/CodingStandards.html说
如果在头文件中定义了一个类并且具有vtable(它具有虚方法或者它来自具有虚方法的类),则它必须始终在类中具有至少一个外联虚拟方法.如果没有这个,编译器会将vtable和RTTI复制到每个.o文件中,其中#include标题,膨胀.o文件大小和增加链接时间.
从我读到的关于Eigen(这里)的内容来看,它似乎operator=()充当了懒惰评估的"障碍" - 例如它导致Eigen停止返回表达式模板并实际执行(优化的)计算,将结果存储到左边的=.
这似乎意味着一个人的"编码风格"对性能产生影响 - 即使用命名变量来存储中间计算的结果可能会对计算的某些部分进行"太早"评估,从而对性能产生负面影响. .
为了验证我的直觉,我写了一个例子并对结果感到惊讶(完整的代码在这里):
using ArrayXf = Eigen::Array <float, Eigen::Dynamic, Eigen::Dynamic>;
using ArrayXcf = Eigen::Array <std::complex<float>, Eigen::Dynamic, Eigen::Dynamic>;
float test1( const MatrixXcf & mat )
{
ArrayXcf arr = mat.array();
ArrayXcf conj = arr.conjugate();
ArrayXcf magc = arr * conj;
ArrayXf mag = magc.real();
return mag.sum();
}
float test2( const MatrixXcf & mat )
{
return ( mat.array() * mat.array().conjugate() ).real().sum();
}
float test3( const MatrixXcf & mat …我的目标是在使用模板模板参数定义其他类型时记录模板化类型的名称.我遇到的问题是结果类型被认为是不等价的.
为了实现这一点,我尝试使用模板化的"使用"别名来记录作为模板模板参数给出的名称.然后我引用别名来恢复名称.这有用的一个例子是当我有一个模板化函数,它返回一个带有需要推导出的模板模板参数的类型.
以下代码显示了我的方法:
include <type_traits>
template<typename X>
struct TT {};
template<template<typename> class T>
struct UU {
template<typename X>
using name = T<X>;
};
template<template<typename> class T>
struct VV {};
int main() {
static_assert(std::is_same<
TT<int>,
UU<TT>::template name<int>
>::value, "Templated type instances are distinct");
static_assert(std::is_same<
VV<TT>,
VV<UU<TT>::template name>
>::value, "Template type instances using template names are distinct");
return 0;
}
编译如下:
c++ -std=c++14 Test.cpp -o Test
产量:
Test.cpp:20:3: error: static_assert failed "Template type instances using template names are distinct"
还有另一种录制和使用模板名称的方法吗？
有人可以指示我指定此行为的标准部分吗？
在c ++ 11中传递lambda非常简单:
func( []( int arg ) {
// code
} ) ;
但我想知道,将lambda传递给像这样的函数的成本是多少？如果func将lambda传递给其他函数怎么办？
void func( function< void (int arg) > f ) {
doSomethingElse( f ) ;
}
lambda的传递是否昂贵？由于可以为function对象分配0,
function< void (int arg) > f = 0 ; // 0 means "not init"
它让我认为函数对象就像指针一样.但是,如果不使用new,则意味着它们可能类似于值类型struct或类,它们默认为堆栈分配和成员方式副本.
当你按"值"传递一个函数对象时,C++ 11"代码体"和捕获的变量组是如何传递的？是否有很多代码体的多余副本？我是否必须标记function传递的每个对象,const&以便不进行复制:
void func( const function< void (int arg) >& f ) {
}
或者以某种方式使函数对象以不同于常规C++结构的方式传递？
我想阻止我的类的用户将它用作自动变量,所以我编写如下代码:
class A {
private:
~A() = default;
};
int main() {
A a;
}
我希望代码不会被编译,但是g ++编译它没有错误.
但是,当我将代码更改为:
class A {
private:
~A(){}
};
int main() {
A a;
}
现在,g ++给出了~A()私有的错误,这是我的期望.
"= default"析构函数和空析构函数之间有什么区别？
c++ ×10
c++11 ×5
c++14 ×2
c++17 ×2
class ×2
templates ×2
c++-concepts ×1
c++-faq ×1
destructor ×1
eigen ×1
g++ ×1
lambda ×1
linker ×1
llvm ×1
overriding ×1
performance ×1
private ×1
pure-virtual ×1
readability ×1
std-function ×1
using ×1
virtual ×1