我正在尝试编写代码，以解决耦合的常微分方程（即ODE）。该功能需要接受一个功能数组，每个功能都是耦合的ODE之一。我正在尝试使用C ++ 17折叠表达式将这些函数传递给master函数，然后由master函数分别将这些函数一次传递给求解器。求解器需要求解方程，并根据结果修改输入图。该映射必须基于第一个函数的结果进行修改，因为修改后的映射是下一个函数的输入。通用代码如下所示。代码经过简化，以突出显示我要解决的问题。
int main()
{
ODESolver q;
std::map<std::string, double> inputs {
{"x", 1.0},
{"y", 2.0},
{"z", 3.0},
{"a", 4.0}
};
auto results = solver(inputs, func1, func2);
}
double func1(std::map<std::string, double> arr)
{
double dcadt = -arr["x"] * arr["y"] + arr["z"] * arr["a"];
return dcadt;
}
double func2(std::map<std::string, double> arr)
{
double dccdt = arr["x"] * arr["y"] - arr["a"] * arr["z"];
return dccdt;
}
该类中的信息如下所示；
class ODESolver
{
public:
template<typename ...Funcs>
std::vector<double> framework(std::map<std::string, double> inputs, Funcs&&... funcs)
{
std::tuple<double, double> …我正在尝试制作一个具有对象向量的类模板，并且能够在它们上运行对象类的功能，所以我不必循环抛出对象并运行该类，我可以像这样
allObjects.runFunc(objectsType::someFunc);
在课堂上我想要3个命令：
add -将项目添加到组中 remove -删除物品 runFunc(someFunc)-那是最重要的一个，我希望它someFunc在该组中的所有对象上 运行并且该类将具有一个变量：
std::vector<Object> objects-将存储所有对象
所以我在互联网上看了很多，还没有找到我需要的东西，但是我尝试使用std :: bind并遇到了一些非常奇怪的故障。
类（在.h文件中）：
#pragma once
#include <vector>
template<class Object>
class Group {
public:
void add(Object &object);
void runFunc(void(Object::* func)(void));
private:
std::vector<Object> objects;
};
template<class Object>
inline void Group<Object>::add(Object &object)
{
objects.push_back(object);
}
template<class Object>
inline void Group<Object>::runFunc(void (Object::* func)(void))
{
for (int i = 0; i < objects.size(); i++)
{
(objects[i].func)();
}
}
我得到的错误是func不是gameObject的成员，其中gameobject是Im正在测试组的类型，是的，它确实具有更新功能。
我想证明没有什么是（受保护的内存地址），整个故事只是关于编译器、操作系统或托管应用程序运行的任何应用程序，只需对托管的读写请求进行一些检查应用程序发送到它的上级进程，这个上级应用程序或你称之为什么决定这个子进程是否有权读取或写入这个特定的内存位置，但是这个 C++ 代码在本质上不起作用，为什么：
#include <iostream>
int main()
{
const int x = 10;
std::cout << &x << std::endl; // So i can view address of x
std::cout << "x Before is equal "<< x <<std::endl;
int y ;
std:: cin >> std::hex >>y;
int *pinter = (int*)y ;
*pinter = 20;
std::cout << "x After is equal "<< x <<std::endl;
}
这段代码应该绕过 c++ 编译器将 x 变量类型设置为const int的概念，这样指向变量的指针（不像在 C 中，指向常量的指针可以改变 constant 的值）和对变量的引用都不能改变变量所以这段代码应该得到变量 x 的地址（当然在它打印出来之后）然后一个指针完成剩下的工作，所以我在这里搞砸了，因为它看起来像这个内存位置是硬件保护的（我知道不是，但我很困惑）
我有两个 std::unordered_map
std::unordered_map<int, int> mp1;
std::unordered_map<int, int> mp2;
我需要找到键值对的交集并将其存储在表单的另一个映射中。
std::unordered_map<int, int> mp;
我怎样才能做到这一点？？
template<class T>
struct E{}; //// no error
template<struct T>
struct F{}; ////error
错误：非类型模板参数不能具有类型“struct T”模板
如果除了默认和访问说明符之外，class和是相同的东西，那么为什么这不起作用？structprivatepublic
为了不用记住删除，我们使用unique_ptr来管理内存。我们的印象是我们可以在内存中写入和读取，只是删除取决于智能指针。但是，以下代码在 i=7220 上崩溃并出现段错误。
怎么了？
#include <memory>
using namespace std;
int main() {
const uint32_t n = 40000000;
uint64_t*p = new uint64_t[n]; // this works, but we have to delete the memory or leak
for (int i = 0; i < n; i++)
p[i] = i;
unique_ptr<uint64_t> mem = make_unique<uint64_t>(n);
uint64_t* p1 = mem.get();
for (int i = 0; i < n; i++) // this crashes at i=7220
p1[i] = i;
return 0;
}
我正在实现一个有限状态机，其中所有可能的状态都存储在std::tuple.
这是我面临的问题的最小编译示例及其 godbolt 链接https://godbolt.org/z/7ToKc3T3W：
#include <tuple>
#include <stdio.h>
struct state1 {};
struct state2 {};
struct state3 {};
struct state4 {};
std::tuple<state1, state2, state3, state4> states;
template<size_t Index>
void transit_to()
{
auto state = std::get<Index>(states);
//Do some other actions over state....
}
void transit_to(size_t index)
{
if (index == 0) return transit_to<0>();
if (index == 1) return transit_to<1>();
if (index == 2) return transit_to<2>();
if (index == 3) return transit_to<3>();
}
int main()
{
for(int i=0; i<=3; …请参阅此线程：https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0806r2.html
它说：
换句话说，一个默认捕获 ([&]) 以拼写出冗余的方式捕获 *this，但另一个捕获 ([=]) 以非冗余方式捕获它。
这表示在 c++17 之前，[=] 捕获this为值，而 [&] 将捕获 [*this]，这是不明确的。所以我进行了一个快速测试，看看 [&] 是否默认捕获 [*this]。
我的测试代码尝试查看 [&] 默认捕获 *this，然后应该调用复制构造函数，并且对其值的任何更改都不会影响原始对象，因为它是副本。
#include<iostream>
using namespace std;
class M{
int mI;
public:
M() : mI(3) { cout << "ctor\n"; }
~M() { cout << "dtor\n"; }
M(const M& m) {
if (this != &m) {
cout << "copy ctor\n";
mI = m.mI;
}
}
M& operator=(const M& m) {
if (this != &m) {
cout << "operator =\n"; …我该如何解决？
我收到错误： 'this' argument has type const but function is not marked const c++ overload operator
template <class T>
class Rational {
private:
T n = 0;
T d = 1;
public:
Rational() = default;
T numerator() {
return n;
}
T denominator() {
return d;
}
};
template <class T>
inline bool const operator ==(const Rational <T> & lhs, const Rational <T>& rhs) {
return lhs.numerator() * rhs.denominator() == lhs.denominator() * rhs.numerator();
}
我还没有接触过 C++20。是否有任何改变C ++明确的类型转换操作符（static_cast，dynamic_cast，const_cast和reinterpret_cast在C ++ 20）？也就是说，任何改进、弃用或新的演员阵容？例如，是否有任何改进可以reinterpret_cast减少出错的可能性？