我有以下代码:
#include <iostream>
#include <complex>
using namespace std;
int main() {
complex<int> delta;
complex<int> mc[4] = {0};
for(int di = 0; di < 4; di++, delta = mc[di]) {
cout << di << endl;
}
return 0;
}
我希望它输出"0,1,2,3"并停止,但它会输出一系列无穷无尽的"0,1,2,3,4,5 ......"
看起来比较di<4效果不好并且总是返回true.
如果我只是评论出来,delta=mc[di],我会像往常一样得到"0,1,2,3".无辜任务有什么问题？
我正在使用带有-O2选项的Ideone.com g ++ C++ 14.
考虑以下 C++ >=17 中的示例代码：
struct A{
A() = default;
A(const A&) = delete;
};
const A f(){ return A{}; }
int main(){
const A& a = f(); // OK
// A& b = f(); // Error: cannot convert 'const A' to 'A&'
const A c = f(); // OK: Copy elision
A d = f(); // OK!?
}
该类A是不可复制的，但由于强制复制省略，我们可以将 的结果f()放入变量中。根据cppreference.com 中的这个页面，上述行为是完全合法的，因为它指定const在发生复制省略时忽略返回值上的量词。
然而，这种行为对我来说似乎非常违反直觉。由于A是不可复制的，我觉得应该没有办法const A变成A（除非你有A::A(const …
我使用 g++ 6.3.0 和 -std=c++14 选项编译了下面的代码。
#include <utility>
#include <iostream>
struct A{
int x;
A(const A&)=default;
A(int x):x(x){}
};
struct B{
A a;
template<class... Args>
B(Args&&... args):a(std::forward<Args>(args)...){
std::cout<<"1!"<<std::endl;
}
explicit B(const A& a):a(a){std::cout<<"2!"<<std::endl;}
};
struct C:B{
using B::B;
};
int main(){
A a{2};
const A& aref=a;
C c=aref; //Implicit conversion
}
我预计它会输出“1！” 因为转换是隐式的，但它输出“2！”。如果我注释掉模板构造函数，它将无法编译。这是正确的行为，还是某种 g++ bug？
我有一个结构模板A<x>和一个+运算符int.
#include <iostream>
template<int x>
struct A{
int a;
};
template<int x>
int operator+(A<x> a, int b){
return a.a+b;
}
我创建了一个B<x>可转换为的结构模板A<x>.
template<int x>
struct B{
int b=3;
operator A<x>(){
return {b+10};
}
};
现在我希望在打电话时B<x>转换成.A<x>B<x> + int
int main(){
std::cout<<(A<12>{9}+10)<<std::endl;//OK
std::cout<<(B<12>{9}+10)<<std::endl;//Error
return 0;
}
我在重载模板类的运算符时读取了隐式转换并写了
template<int x>
struct B{
int b=3;
operator A<x>(){
return {b+10};
}
friend int operator+(A<x> a, int b);
}; …我有以下代码来测试我的 constexpr 可构造惰性类：
#include <optional>
template <class T>
class Lazy
{
using initializer_t = T (*)();
std::optional<T> m_val = std::nullopt;
initializer_t m_initializer;
public:
constexpr Lazy(initializer_t initializer = initializer_t{[] { return T{}; }}) noexcept
: m_initializer{initializer} {}
T& operator*()
{
if (!m_val.has_value()) {
m_val = m_initializer();
}
return *m_val;
}
constexpr T* operator->() { return &(**this); }
};
#include <iostream>
struct A {
int f() { return 10; }
~A()
{
std::cout << "Goodbye A " << (void*)this << std::endl; …我知道左值可以转换成const引用.我很好奇我是否可以获得指向这些左值的指针.
如果我写
const int* p = &3; //ERROR: lvalue required as unary operand '&'
我收到这个错误.然而,
const int* p = &((const int&)3);
这个编译.在这种情况下,*p的结果是否保证为3？
我正在编写一个解决这个益智游戏的程序:给出一些数字和一个目标数,然后使用n个数字和运算符+, - ,*,/和()来设定目标数.例如,给定2,3,5,7和目标号10,解决方案是(2+3)*(7-5)=10,3*5-(7-2)=10等等.
美中不足的是,如果我天真地实现它,我会得到一堆相同的解决方案,如(2+3)*(7-5)=10和(3+2)*(7-5)=10,和3*5-(7-2)=10和5*3-(7-2)=10和3*5-7+2=10和3*5+2-7=10等.所以我想检测那些相同的解决方案并修剪它们.
我目前正在使用随机生成的双数来检测相同的解决方案.我正在做的基本上是将这些随机数替换为解决方案,并检查是否有任何一对计算到相同的数字.我必须在我的搜索的每个节点执行检测,所以它必须很快,我现在使用hashset.
现在问题是计算带来的错误.因为即使是相同的解决方案也不会计算到完全相同的值,因此当存储在hashset中时,我目前将计算值舍入为精度.然而,这似乎不能很好地工作,并且每次针对同一问题给出不同数量的解决方案.有时随机数很差,并修剪一些完全不同的解决方案.有时,计算值位于舍入函数的边缘,并输出两个(或更多)相同的解.有一个更好的方法吗？
编辑:"相同"我的意思是两个或更多的解决方案(f(w,x,y,z,...)和g(w,x,y,z,...))计算相同的数字无论什么原始数字(w,x,y,z ......)是.更多示例,4/3*1/2和1*4/3/2和(1/2)/(3/4)相同,但是4/3/1/2和4 /(3*1)/2不是因为如果你将1改为其他数字,它们将不会产生相同的结果.
我是 Haskell 的新手，我有以下代码：
second (x:y:xs) = y : second xs -- returns every second element of a list
second _ = []
xs = [1,2,3,4] ++ second xs
我期望xs被评估为[1,2,3,4,2,4,4]，因为这是固定点，即[1,2,3,4,2,4,4] == [1,2,3,4] ++ second [1,2,3,4,2,4,4]。
然而，当我尝试xs在 GHCi 中进行评估时，我得到了
Prelude> xs
[1,2,3,4,2,4,4
但它不会停止计算。
谁能解释为什么这不会停止，有没有一种简单的方法可以使计算停止并返回[1,2,3,4,2,4,4]？
haskell infinite-loop lazy-evaluation infinite-recursion fixpoint-combinators