我有一个复杂的算法.它使用许多变量,在初始化时计算辅助数组,并沿途计算数组.由于算法很复杂,我将其分解为几个函数.
现在,我实际上并没有看到这可能是一种习惯性的方式; 我的意思是,我只是习惯将算法作为函数.用法只是:
Calculation calc(/* several parameters */);
calc.calculate();
// get the heterogenous results via getters
另一方面,将它放入类中具有以下优点:
混合方式是将算法类放入源文件中,并通过使用它的函数访问它.算法的用户不会看到该类.
有没有人有宝贵的想法可以帮助我？
非常感谢你提前!
I have a 56-bit number with potentially two set bits, e.g., 00000000 00000000 00000000 00000000 00000000 00000000 00000011. In other words, two bits are distributed among 56 bits, so that we have bin(56,2)=1540 possible permutations.
I now look for a loss-free mapping of such an 56 bit number to an 11-bit number that can carry 2048 and therefore also 1540. Knowing the structure, this 11-bit number is enough to store the value of my low-density (of ones) 56 bit …
下面的代码迫切需要: values()编译,至少在ideone :: C++ 14中:
#include <iostream>
template<int N>
struct Table
{
constexpr Table() : values()
{
for (auto i = 0; i < N; ++i)
{
values[i] = i * i * i;
}
}
int values[N];
};
int main() {
constexpr auto a = Table<1000>();
for (auto x : a.values)
std::cout << x << '\n';
}
但为什么？我有想法"值也可以非constexpr方式初始化,而值()明确表示我们以符合constexpr的方式初始化它".但是并不是: values()一目了然吗？
说,我想迭代一些内联定义的对.是否有更短的写作方式:
for(auto pair : std::initializer_list<std::pair<int,int>>{{1,2}, {3,4}})
// ...
？
我指的是将“ uncasting” unique_ptr <Base>到unique_ptr <Derived>的后续问题，这本身对我来说很有意义。
OP要求unique_ptr<Derived>退出a unique_ptr<Base>，后者的对象是动态类型的Derived，因此静态向下转换将是安全的。
通常，（如Internet上95％的解决方案所示，粗略估计），简单的解决方案是：
unique_ptr<Derived> ptr(static_cast<Derived*>(baseClassUniquePtr.release()));
OP也指出，
PS。更为复杂的是，某些工厂驻留在运行时动态加载的DLL中，这意味着我需要确保在与创建对象相同的上下文（堆空间）中销毁所生成的对象。所有权转移（通常发生在另一个上下文中）必须随后提供原始上下文中的删除器。但是除了必须提供/强制释放删除器以及指针之外，强制转换问题应该相同。
现在，解决方案似乎是从该unique_ptr<Base>对象获取删除器并将其传递给新对象，这显然会导致unique_ptr<Derived, default_delete<Base>>。但是default_delete反正是无状态的。唯一的区别是模板参数。但是由于我们总是dtor virtual在C ++中将继承与动态多态性一起使用时进行声明~Derived，因此无论如何我们总是调用，因此我认为，原始的deleteer仍然是安全的，允许进行干净的unique_ptr<Derived>强制转换（没有不方便的第二个模板参数，该参数禁止任何常规存储） 。
因此，虽然我了解使用库（DLL，.dylib，...）创建一个对象并将其传递给某个可执行文件时有两个堆空间，但我不了解如何从旧版本复制/移动无状态删除器对象解决了这个问题。
难道它甚至解决这一问题？如果是，怎么办？如果没有，我们如何解决这个问题？
---编辑：还... get_deleter返回对旧对象的引用，该对象在unique_ptr销毁旧对象时unique_ptr被销毁，不是吗？---（愚蠢的问题，因为unique_ptr显然与删除器一起移动）
让我们举一个最简单的例子：
配方1：
std::vector<int> vec;
// add 10E11 elements
for(std::size_t n = 0; n < vec.size(); ++n)
// ...
配方2：
std::vector<int> vec;
// add 10E11 elements
for(std::vector<int>::size_type n = 0; n < vec.size(); ++n)
// ...
自然，unsigned int或任何不适当的数据类型在这里都不起作用，我们必须编译 x64。我的问题是：在任何情况下，第一个公式是否会导致问题，或者我们是否可以安全地始终使用这种更短的符号来编写它？如果它们很容易覆盖（x86、任何其他容器、.的其他应用程序size_type），我也会对类似的设置感兴趣。
我想知道是否可以通过检查其校验和以某种方式检查我的应用程序是否修改。
因此，例如：
int main()
{
const std::string checksum = "98123abc1239";
std::string myChecksum = calculateChecksumOfThisApp();
if(checksum != myChecksum)
std::cerr << "This application is invalid. Please check if the download has been successful." << std::endl;
}
显然，这里的问题是编译我的应用程序、获取可执行文件的校验和并将其插入到我checksum更改的应用程序校验和中。
我可以将校验和外部存储在某个文件中，但我希望其他人无法操作 exe 的附带好处。他们可以再次计算校验和并将其放入校验和文件中，因此不会从中获得任何好处。
有没有办法创建这样的自检？
有没有惯用的方法（一些现有功能）来减少
[[0 => 'zero'], [1 => 'one']]
至
[0 => 'zero', 1 => 'one']
？
仅创建一个完成任务的循环很容易，但是效率似乎很低，我显然希望在这里使用单线。
编辑：哦，这是随机的，0和1彼此跟随。该数组也可以是[[2 => 'two'], [3 => 'three']]
我过去习惯于clock()获得算法的CPU时间.但是,它似乎不再起作用了.我有一个带有8个CPU的Windows 10 VM,也可以在资源监视器中看到.
现在,我像这样测量时间:
auto startTime = std::chrono::high_resolution_clock::now();
auto startClocks = std::clock();
// some code with TBB that uses multiple threads
auto endTime = std::chrono::high_resolution_clock::now();
auto endClocks = std::clock();
auto duration = endTime - startTime;
auto clockDuration = endClocks - startClocks;
auto durationSeconds = static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()) / 1000.;
auto durationCpuSeconds = 1. * clockDuration / CLOCKS_PER_SEC;
TBB部分确实有效,正如我在Windows资源监视器中看到的那样,所有CPU都可以100%运行.如果我在没有并行化的情况下启动无限循环,则CPU使用率仅为预期的12.5%.
然而,durationSeconds并且durationCpuSeconds完全一样......
我用手表测量了时间,结果是墙上的时间.因此,clock()显然没有显示CPU时间应该大大高于8个并行工作的CPU.是clock()不可靠的还是我失去了一些东西？
在某些情况下,我看到的一些代码hashValue用于转换Bool为Int.
但是,代码
let someValue = true
let someOtherValue = false
print(someValue.hashValue)
print(someOtherValue.hashValue)
得到我的输出
-5519895559129191040
7814522403520016984
我希望1和0,虽然.
我使用XCode 10.0 beta 2(10L177m),MacOS High Sierra和Swift 4.2.我可以切换到Swift 4.0以获得同样的结果.
现在,有什么我做错了或hashValue没有可靠的转换方法？
通常，在编写 C++ 代码时，我会将对象始终作为普通属性保存，从而利用 RAII。然而，在 QT 中，删除对象的责任可以在QObject. 所以，假设我们定义了一些特定的小部件，那么我们有两种可能性：
1）使用QT的系统
class Widget1 : QWidget
{
Q_OBJECT
public:
Widget1(QWidget* parent = nullptr);
private:
QPushButton* myButton; // create it with "new QPushButton(this);"
};
2）使用RAII
class Widget2 : public QWidget
{
Q_OBJECT
public:
Widget2(QWidget* parent = nullptr);
private:
QPushButton button; // normal RAII
};
通常，我使用第一种方法。如果父母不仅通过布局了解其孩子，似乎有些事情会更好。但是仔细想想……真正的原因我还不是很清楚。
我知道堆栈是有限的。但是，假设这在这里不起作用。毕竟，堆栈不是那么小。