我想建立一个可以选择constexpr-ness的课程.当然,我想利用编译时错误检查.
constexpr当给定参数不是常量表达式时,包含的每个函数(构造函数)也必须在运行时工作.这应该是为什么每次你使用的原因static_assert在constexpr功能后,它无法编译函数参数.
这样说,我已经读过,可以使用抛出mechnanism的异常,因为当函数被调用为常量表达式时,可以在编译时评估这些异常.如果可行,那么对于功能问题就解决了.
但是问题仍然没有解决构造函数,因为constexpr构造函数似乎必须没有正文......所以看起来我不能从那里使用异常抛出!
任何的想法？
似乎在 C++ 中，在静态内存中完全拥有字符串文字的唯一方法是将它们声明为：
class A
{
static const char const * = "Hello World";
};
我注意到std::string没有常量表达式构造函数。我知道std::string实现基于动态分配，但为什么没有另一个符合std::string 的字符串类可以完成这项工作？
在Alexandrescu 基于策略的设计中我不理解的是创建没有任何共同点的新类型,在我看来,仍然存在许多应该以某种方式表示的共同点.
例如,std::string和std::basic_string<>:allocator是非常内部的东西,在我看来,使用该类的代码不应该知道该类正在使用哪个分配器.
但是,因为已经创建了一个新类型,所以std::basic_string_1,所有那些传递的std::string&方法基本上都被破坏了,我看不出一个有效的理由,为什么std::basic_string<>不同的分配器被认为std::basic_string<>与另一个分配器完全不同.
我的问题是:为什么每个人都没有共同的父母std::basic_string<>,这样可以避免这个问题？一般在我的代码中,当我有一个Whatever<T>,我使它继承WhateverBase某种类型,当T它没有显示在该类的公共接口上时,它工作得非常好......
从"一个不应该使用原始指针"成语的角度出发,我正在寻找智能指针来找到哪一个最适合引用关系.
通过引用关系,我的意思与此代码相同:
class A
{
public:
A(B & b) :
m_refB( b )
{ }
private:
B & m_refB; // A refers to B
};
但是没有使用引用的所有缺点(以后不能绑定,不能重新分配,A不能再默认构造等).
然而,每个智能指针以其自己的语义表达所有权概念.它们甚至以这种所有权概念命名(当所有权仅对一个对象是唯一的时,唯一指针,当所有权在更多对象之间共享时共享指针等).
我想表达的是A指的是B,但是A不拥有B.可以std::reference_wrapper< B >做这个工作,或者那是错误的用法吗？
在C++中定义了太多类型是否有任何运行时成本或开销？例如,这两段代码之间是否有任何区别:
int main()
{
int x, y;
double fx, fy;
return 0;
}
和:
template<typename T>
struct Point
{
T x, y;
};
int main()
{
Point<int> p;
Point<double> fp;
return 0;
}
想象一下具有许多模板化类型的代码,因此在编译时它会生成更具体的类型:它是否会在运行时产生任何影响？我主要担心的是静态内存消耗.
我有以下代码使用多重继承.目的是在派生类中使用两个接口作为一个接口:
struct InterfaceA
{
virtual void register_stuff();
virtual void on_state_changed( const State state ) = 0;
};
struct InterfaceB
{
virtual void register_stuff();
virtual void on_state_changed( const State state ) = 0;
};
struct Derived : InterfaceA, InterfaceB
{
void register_stuff() override
{
InterfaceA::register_stuff();
InterfaceB::register_stuff();
}
void on_state_changed( const State state ) override
{
// how can I know who is responding?
}
};
注册接口将导致异步调用on_state_changed.是否有可能辨别哪个接口正在调用它？
我在C ++ 17上使用GCC 7.3，但我不明白为什么此行失败：
template <typename... Args>
using X = std::invoke_result<std::tie, Args...>::type;
错误是：
error: type/value mismatch at argument 1 in template
parameter list for ‘template<class _Functor, class ... _ArgTypes>
struct std::invoke_result’
using X = std::invoke_result<std::tie, Args...>::type;
note: expected a type, got ‘std::tie’
我不明白为什么std::invocable在以下代码中lambda 和函数都没有被识别为兼容类型：
#include <concepts>
#include <iostream>
void f( std::invocable auto callback)
{
callback(47);
}
void function_callback(int i)
{
std::cout << i << std::endl;
}
auto lambda_callback = [](int i )
{
std::cout << i << std::endl;
};
int main(int)
{
f(&function_callback);
f(lambda_callback);
}
我正在使用-std=c++2a启用了标志的GCC 主干。
我正在使用一个库,其中包含许多使用PIMPL习语构建的类.在我看来,我发现不好的是,这些类是使用a std::shared_ptr实现的.这意味着对象实际上是"隐式共享"的.我的问题是:这是实施PIMPL的正确方法吗？或PIMPL和"隐式共享"是两种不同的习语,因此默认情况下不应该混合使用？处理复制语义的正确方法是什么？
如何将模板化函数与STL提供的算法一起使用<algorithm>？例如,此代码无法编译,因为编译器无法推导出该predicate函数的模板参数:
#include <iostream>
#include <algorithm>
template< typename CharType >
bool predicate( const CharType& c )
{
return c == '0';
}
std::string
process_string( const std::string& str )
{
std::string result;
std::copy_if( str.begin( ),
str.end( ),
std::back_inserter( result ),
predicate );
return result;
}
int main()
{
std::cout << process_string("AK0NNDK0ASDAS0") << std::endl;
return 0;
}