标准C库函数strtof并strtod具有以下签名:
float strtof(const char *str, char **endptr);
double strtod(const char *str, char **endptr);
它们将输入字符串分解str为三部分:
如果endptr不是NULL,则*endptr设置为指向紧跟在转换的一部分的最后一个字符之后的字符的指针(换句话说,尾随序列的开始).
我想知道:endptr那么,为什么指向非const char指针？不是*endptr指向const char字符串的指针(输入字符串str)？
我试图从我的类中生成一个线程,并且该线程在我的类中执行一个特定的方法.代码如下所示:
class ThreadClass{
int myThread(int arg){
// do something
}
void createThread(){
thread t = thread(myThread,10);
}
} ;
编译时的这段代码会引发错误说法
std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = int (ThreadClass::*)(int), _Args = {int}]
no known conversion for argument 1 from ‘<unresolved overloaded function type>’ to ‘int (ThreadClass::*&&)(int)’
我不确定这里的实际错误是什么.有人可以帮我弄这个吗？
谢谢.
在我的图形应用程序中,我想在另一个线程中生成批处理网格.因此我异步调用成员函数使用std::async.
task = async(launch::async, &Class::Meshing, this, Data(...));
在我的更新循环中,我尝试检查线程是否准备好.如果是,我会将网格发送到视频卡并启动下一个线程.如果没有,我将跳过这些操作.
#include <future>
using namespace std;
class Class
{
public:
void Update()
{
if(task.finished()) // this method does not exist
{
Data data = task.get();
// ...
task = async(launch::async, &Class::Meshing, this, Data(/* ... */));
}
}
private:
struct Data
{
// ...
};
future<Data> task;
Data Meshing(Data data)
{
// ...
}
};
如何在不更新功能的情况下检查异步线程是否完成？
考虑以下示例,我们解析数据并将结果传递给下一个函数:
Content Parse(const std::string& data);
void Process(Content content);
int main()
{
auto data = ReadData();
Process(Parse(data));
}
现在让我们使用更改代码std::optional来处理失败的解析步骤:
optional<Content> Parse(const std::string& data);
void Process(Content content);
int main()
{
auto data = ReadData();
auto content = Parse(data);
if (content)
Process(move(*content));
}
移动是否有效optional<T>::value()？如果它std::optional可以,它也有效boost::optional吗？
boost::to_string(发现于boost/exception/to_string.hpp)的目的是什么？它boost::lexical_cast<std::string>和它有什么不同std::to_string？
我想多次向std :: vector添加一个值.例如,将向量值1添加到向量中五次:
std::vector<int> vec;
vec.add(1, 5);
之后vec的格式应为{1,1,1,1,1}.有一个干净的c ++方法吗？
我正在使用std::bind但是当我们将它与成员类函数一起使用时,我仍然不知道它是如何工作的.
如果我们有以下功能:
double my_divide (double x, double y) {return x/y;}
我完全理解下一行代码:
auto fn_half = std::bind (my_divide,_1,2); // returns x/2
std::cout << fn_half(10) << '\n'; // 5
但是现在,通过以下代码我们有一个绑定到成员函数我有一些问题.
struct Foo {
void print_sum(int n1, int n2)
{
std::cout << n1+n2 << '\n';
}
int data = 10;
};
Foo foo;
auto f = std::bind(&Foo::print_sum, &foo, 95, _1);
f(5);
为什么第一个参数是参考？我想得到一个理论上的解释.
第二个参数是对象的引用,对我来说是最复杂的部分需要理解.我认为这是因为std::bind需要一个背景,我是对的吗？总是这样吗？std::bind当第一个参数是成员函数时,是否有某种实现要求引用？
我想交换两个固定大小的整数数组。
与直觉相反，以下内容无法编译，因为没有swap找到匹配的实例。
#include <array>
#include <utility>
int main()
{
std::array<int,3> a, b;
std::swap< std::array<int,3> >( a, b );
return 0;
}
我觉得这很令人惊讶。但是，用编译替换交换std::swap(a,b)并且（根据 VSCode）具有签名
inline void std::swap<int, 3UL>(std::array<int, 3UL> &__one, std::array<int, 3UL> &__two)
我也无法理解。
问：这是怎么回事？
今天,我偶然发现了构造函数的这些标准声明std::vector:
// until C++14
explicit vector( const Allocator& alloc = Allocator() );
// since C++14
vector() : vector( Allocator() ) {}
explicit vector( const Allocator& alloc );
在大多数标准容器中都可以看到这种变化.一个稍微不同的例子是std::set:
// until C++14
explicit set( const Compare& comp = Compare(),
const Allocator& alloc = Allocator() );
// since C++14
set() : set( Compare() ) {}
explicit set( const Compare& comp,
const Allocator& alloc = Allocator() );
两种模式之间有什么区别？它们(dis)的优势是什么？
它们是否完全等效 - 编译器是否生成类似于第一个的第二个类似的东西？
似乎有一个问题,使用C++中的文字istd::complex.
请考虑以下代码:
std::complex<double> a = -1.0i * 42.0;
std::complex<double> b = a + 1.0i;
第二行无法编译:
error: no match for ‘operator+’ (operand types are ‘std::complex<double>’ and ‘__complex__ double’)
在函数调用中使用复杂文字时也会出现这种情况,例如
std::exp<std::complex<double>>( 1.0i * 3.14159 );
为什么复杂的字面值1.0i不能转换为std::complex<double>？
我必须明确地构建一个std::complex与1.0i？