asianirish's questions

为什么这段代码会抛出错误：

const MSG: &str = "Hello";

fn one_of(_first: &str, _second: &str) -> &str {
    MSG
}

我向我的铁杆朋友（gpt-4-1106-preview）问了这个问题，他回答说：

该代码会抛出错误，因为 Rust 无法保证引用的字符串的生存MSG时间足够长，足以安全地使用函数返回的引用one_of

好吧，好吧，那么为什么这个函数不会导致错误：

const MSG: &str = "Hello";

fn one(_first: &str) -> &str {
    MSG
}

我朋友回复：

当声明函数时one未显式指定返回引用的生存期时，编译器将使用生存期推断并发现返回值MSG具有静态生存期。因此，编译器假定该函数返回具有静态生命周期的引用，并且此推论与输入参数的生命周期兼容（在本例中忽略该参数，因为它不用于确定返回值的生命周期） ）。

我的合理反对：

但是在 one_of 的情况下，编译器可以自动为该函数分配静态生命周期，就像在 one 的情况下一样，为什么您所说的有关 one 的所有内容在 one_of 函数的情况下都无效？

我的朋友终于崩溃了，开始为“造成的混乱”道歉，并表示这两个函数不应该导致错误（即使它们没有）。

我们需要生物神经网络的帮助，那就是你，亲爱的皮革和骨头朋友！解释一下主题

fn main() {   
    let mut n = 123;
    let m = &mut n;

    println!("n: {}", n);
    println!("&n: {}", &n);
    
    //*m = 332; // Ошибка!
    modify_ref333(&mut n); // почему же так нормально, 
    // несмотря, что предыдущая строка вызывает ошибку? 
    // ведь она делает ТОЖЕ САМОЕ!

    println!("n: {}", n);
    println!("&n: {}", &n);  
}

fn modify_ref333(m: &mut i32) {
    *m = 333; // ok
}

如果注释掉*m = 332;，main会抛出错误

错误[E0502]：不能n作为不可变借用，因为它也作为可变借用

这被解释了，而且似乎是可以理解的。但！毕竟，该函数modify_ref333做同样的事情——它使用一个可变引用，为地址分配一个值。结果是目标（正如他们在官方教科书中所写的那样）

不可变引用的用户不要期望值会突然从他们下面改变！

只要我们有对相同值的不可变引用，我们也不能有可变引用。不可变引用的用户不要期望值会突然改变！

还没到！“欺骗”编译器这么容易，还是有区别？

PS这就是它的工作原理：

fn main() {
    let mut n = 123;
    
    println!("n: {}", n);
    println!("&n: {}", &n);
    
    let m = &mut n;
    *m = 332;

    println!("n: {}", n);
    println!("&n: {}", &n);  
}

任何人都可以提出一个关于如何使用可变链接的简明规则，以及如何不，我没有在码头找到它（或者更确切地说，那里写的内容被一个例子违反了）

例如，我正在制作一个包含另一个容器模板的自定义容器，并且我想在模板中不仅定义键和值的类型，还定义容器本身的类型，例如hash或map。我认为说明我观点的最好方法是举一个例子：

template <typename C, typename K, typename T>
class SuperContainer
{
public:
    void insert(const K &key, const T &value) {
        _innerContainer.insert(key, value);
    }
    T at(const K &key) const {
        return _innerContainer.value(key);
    }

private:
    C<K, T> _innerContainer;
};

int main(int argc, char *argv[])
{
    SuperContainer<QHash, int, QString> sc1;
    SuperContainer<QMap, int, QString> sc2;
//...

在这种形式下，这是一个不工作的代码，但是这个想法怎么能通过其他方式实现呢？

或者还有哪些其他的宪法和法律保障可以借助软件来确保公民意志的真实性？例如，公民如何确保软件不考虑他们离线投票的投票（最近发现的漏洞，发现它的人为此付出了代价）？是否可以从当前软件中删除哈希码并将其与已发布的源进行比较。志愿程序员可以去哪里寻找漏洞？

如果源代码没有公布，你可以提出什么保护措施（除了盲目相信选举委员会的能力和善意）以及在当前的国家模式下提出这些建议的程序是什么？

该问题仅涉及问题的技术方面，以及对公民利益的保护，无论他们属于哪个阵营，因此请不要提出政治讨论-还有许多其他有趣的论坛。

例如，我需要将一组对象写入文件，为此我必须使用一个或另一个代表NodeConstructor. 一般来说，我做了一个功能：

virtual NodeConstructor<Node> *NodeConstructor::nodeConstructor(const Node *child) const = 0;

它应该将每个对象（根据其类）与一个或另一个匹配NodeConstructor以记录其字段。在我的特殊情况下，我暂时不使用RTTI，因为每个子对象都有一个所谓的“角色”（我不会停止它是什么，但直观地说，我认为它是可以理解的），我可以匹配相应的NodeConstructor. 但是在一般情况下，当没有这样的“角色”或任何其他标识符时呢？

我的想法是使用typeid每个对象并比较它们。但是我记得，老派教说使用RTTI它不是一个好习惯，他们说，它会消耗很多资源，有必要单独启用该选项，通常是设计不佳的标志。

C++11 及更高版本的新学校对此有何看法？毕竟，据我了解，使用auto已经暗示包含 RTTI，并且auto现在在 C++ 1x 中使用被认为是好的做法。从我找到的信息来看，资源的消耗取决于编译器。并且为了连载的目的，使用typeid还不错的设计，即“按计划”。我想看看你对此事的反对意见和判断？

QT5.12.3我为设备编译armbian。对于配置 ( ./configure)，我使用以下选项：

./configure -prefix /home/asianirish/Install/qt5/qtbase -opensource -confirm-license \
    -debug \
    -prefix /home/asianirish/Qt-custom/qt-embedded-5.12.3 \
    -sysroot /home/asianirish/img/armbian \
    -c++std c++11 \
    -device linux-arm-generic-g++ \
    -device-option CROSS_COMPILE=/usr/bin/arm-linux-gnueabihf- \
    -openssl \
    -no-widgets \
    -no-gif -qt-libpng -qt-libjpeg \
    -no-opengl \
    -skip qtwebengine \
    -nomake examples \
    -v

配置以成功结束：

/*
Note: Also available for Linux: linux-clang linux-icc

Note: No wayland-egl support detected. Cross-toolkit compatibility disabled.

WARNING: QDoc will not be compiled, probably because libclang could not be located. This means that you cannot build the Qt documentation.

Either ensure that llvm-config is in your PATH environment variable, or set LLVM_INSTALL_DIR to the location of your llvm installation.
On Linux systems, you may be able to install libclang by installing the libclang-dev or libclang-devel package, depending on your distribution.
On macOS, you can use Homebrew's llvm package.
On Windows, you must set LLVM_INSTALL_DIR to the installation path.

Qt is now configured for building. Just run 'make'.
Once everything is built, you must run 'make install'.
Qt will be installed into '/home/asianirish/img/armbian/home/asianirish/Qt-custom/qt-embedded-5.12.3'.

Prior to reconfiguration, make sure you remove any leftovers from
the previous build.
*/

但是执行后make会报错：

...
In file included from kernel/qdnslookup_unix.cpp:59:0:
/usr/arm-linux-gnueabihf/include/gnu/lib-names.h:8:33: fatal error: gnu/lib-names-soft.h: No such file or directory
compilation terminated.
Makefile:20940: recipe for target '.obj/qdnslookup_unix.o' failed
make[3]: *** [.obj/qdnslookup_unix.o] Error 1
make[3]: Leaving directory '/home/asianirish/Install/qt5/qtbase/src/network'
Makefile:273: recipe for target 'sub-network-make_first' failed
make[2]: *** [sub-network-make_first] Error 2
make[2]: Leaving directory '/home/asianirish/Install/qt5/qtbase/src'
Makefile:50: recipe for target 'sub-src-make_first' failed
make[1]: *** [sub-src-make_first] Error 2
make[1]: Leaving directory '/home/asianirish/Install/qt5/qtbase'
Makefile:89: recipe for target 'module-qtbase-make_first' failed
make: *** [module-qtbase-make_first] Error 2

我进去了/usr/arm-linux-gnueabihf/include/gnu/，可以肯定的是，只有谎言lib-names-hard.h，lib-names-soft.h那里没有！

>pwd
/usr/arm-linux-gnueabihf/include/gnu
>ls
libc-version.h  lib-names-hard.h  stubs-hard.h
lib-names.h     stubs.h           stubs-soft.h

这是什么lib-names-soft.h？我爬进去lib-names.h看看：

#if !defined __ARM_PCS_VFP
# include <gnu/lib-names-soft.h>
#endif
#if defined __ARM_PCS_VFP
# include <gnu/lib-names-hard.h>
#endif

我用谷歌搜索__ARM_PCS_VFP，发现这是一种使用浮点数的方法——硬件或软件。好吧，好吧，我决定做一个肮脏的 hack - 我linux_device_post.conf在文件中添加一行（来自开源 QT 包）：

#Внимание, грязный хак, не повторяйте!
QMAKE_CFLAGS        += -mfloat-abi=hard

但是，正如预期的那样 - 失败：

/*
collect2: error: ld returned 1 exit status
Makefile:1230: recipe for target '../../lib/libQt5Core.so.5.12.3' failed
make[3]: *** [../../lib/libQt5Core.so.5.12.3] Error 1
make[3]: Leaving directory '/home/asianirish/Install/qt5/qtbase/src/corelib'
Makefile:223: recipe for target 'sub-corelib-make_first' failed
make[2]: *** [sub-corelib-make_first] Error 2
make[2]: Leaving directory '/home/asianirish/Install/qt5/qtbase/src'
Makefile:50: recipe for target 'sub-src-make_first' failed
make[1]: *** [sub-src-make_first] Error 2
make[1]: Leaving directory '/home/asianirish/Install/qt5/qtbase'
Makefile:89: recipe for target 'module-qtbase-make_first' failed
make: *** [module-qtbase-make_first] Error 2
*/

有没有人遇到过这样的问题？哪里可以买到这个 lib-names-soft.h？我认为滑倒它会是一个更肮脏的黑客，所以我什至不会尝试。也许在配置中更改它-device-option？或者-device？为了什么？在哪里挖？

如果派生类有一个名称相同但签名不同的函数？

例子。创建一个TwoStageMap公开继承自的类QMap：

template<typename F, typename S, typename T, typename Cont = QMap<S, T>>
class TwoStageMap : public QMap<F, Cont>
{
public:
    void insert(const F &fkey, const S &skey, const T &value1); //TODO: return an iterator of what?

    void insert(const QPair<F, S> &pair, const T &value1);

    T value(const F &fkey, const S &skey);

    T value(const QPair<F, S> &pair);

};

当尝试使用value()派生类 ( TwoStageMap) 的签名进行访问时，一切正常：

TwoStageMap<int, QString, QString, NamedArgList<QString>> tsMap;

tsMap.insert(31, "October", "Halloween");
tsMap.insert(31, "December", "New Year's Eve");
tsMap.insert(25, "December", "Xmas");
tsMap.insert({25, "October"}, "Canna");

qDebug() << "Day1:" << tsMap.value1(31, "December");

，但是一旦我们尝试调用value()自身QMap（获取第一个键下的内部容器），tsMap.value(31);我们立即得到一个错误：

没有匹配的成员函数调用“值”

例如，将函数重命名为value1()问题就消失了。问题是，这是编译器错误还是语言标准？编译器gcc x86 64bit

类实现，如果有人想使用/尝试它：

template<typename F, typename S, typename T, typename Cont>
void TwoStageMap<F,S,T,Cont>::insert(const F &fkey, const S &skey, const T &value)
{
    Cont innerMap;
        if (QMap<F, Cont>::contains(fkey)) {
            innerMap = QMap<F, Cont>::value(fkey);
        }

    innerMap.insert(skey, value);
    QMap<F, Cont>::insert(fkey, innerMap);

    //TODO: return an iterator of what?
}

template<typename F, typename S, typename T, typename Cont>
void TwoStageMap<F,S,T,Cont>::insert(const QPair<F, S> &pair, const T &value)
{
    return insert(pair.first, pair.second, value);
}

template<typename F, typename S, typename T, typename Cont>
T TwoStageMap<F,S,T,Cont>::value(const F &fkey, const S &skey)
{
    auto innerMap = QMap<F, Cont>::value(fkey);
    return innerMap.value(skey);
}

template<typename F, typename S, typename T, typename Cont>
T TwoStageMap<F,S,T,Cont>::value(const QPair<F, S> &pair)
{
    return value1(pair.first, pair.second);
}

PS 在示例中从派生模板类的函数调用模板基类的成员函数，模板父类的非限定函数名不可见的情况，这个没有问题，如你所见，我正在通过 访问，这是一个稍微不同QMap<F, Cont>::的情况，但问题是什么阻止编译器使用所谓的. “歪曲姓名”？如果这是一个语言标准，那么委员会更有可能提出这个问题

实际作用：

QString Util::uniqueStringMs36()
{
    static qint64 uniqueVoucher = 0;//to guarantee the uniqueness if the same
    qint64 ms = QDateTime::currentMSecsSinceEpoch();
    static qint64 prevMs = 0;

    if (ms > prevMs) {
        uniqueVoucher = 0;
    }

    ms += uniqueVoucher;
    prevMs = ms;
    uniqueVoucher++;

    return QString::number(ms, 36); //base 36
}

虽然写在 中QT，你可以很容易想象std，主要问题是算法是否有效——我们从 Unix 纪元读取毫秒，我们报告一个特殊变量的值正在递增（如果函数在同一毫秒内调用）

其实在这个问题上，简单得不得了，但在谷歌上却没有找到答案。在 qtcreator 中编译时，我注意到模板类没有对应的 .o 文件。好吧，明明是没有对应的.cpp，但毕竟理论上一个模板类，在使用的时候，会动态生成一个“正常”的类，并带有对应的类型参数，对吧？以及如何在没有对象中介的情况下将此类的功能“获取”到可执行文件中？直接地？如果目标文件是如此不需要，那么它们甚至是为了什么？

创建基于以下的队列类型Seq：

import Data.Sequence

type Queue v = Seq v

现在我想编写一个返回队列第一个元素（“头”）的函数。从我阅读和谷歌搜索的所有内容看来，应该是这样的：

qhead :: Queue v -> v
qhead Empty = error "empty sequence"
qhead (x :<| xs) = x

赛皮特：

不在范围内：数据构造函数 ':<|'

好的，我是这样做的：

qhead' :: ViewL v -> v
qhead' EmptyL = error "empty sequence"
qhead' (x :< xs) = x

qhead :: Queue v -> v
qhead q = qhead' $ viewl q

但也许可以做一些更笨拙的事情？直接用typeQueue来比较，不介意一些笨蛋ViewL吗？还是这么犹太？

完整代码：

import Data.Sequence

type Queue v = Seq v

qhead' :: ViewL v -> v
qhead' EmptyL = error "empty sequence"
qhead' (x :< xs) = x

qhead :: Queue v -> v
qhead q = qhead' $ viewl q

{-
*R.QTree> qhead $ fromList [12,13,14,15]
12
-}

标准列表 ( [a]) 允许您在列表末尾快速插入并从列表末尾快速删除。

假设我们可以push为它创建一个“类似列表”的类型和一个函数，以保持“快速”添加的第一个元素可用，以便我们可以有效地循环从最旧到最新的队列：

data Queue a = Empty | Element a (Queue a)

push :: a -> Queue a -> Queue a
push a Empty             = Element a Empty
push a (Value b pointer) = Element b (push a pointer)

但是有一个明显的缺点——添加一个新元素时，它会递归地“深入”到队列中，即随着队列的增长，新添加的速度会越来越慢。

本质上，这是一个问题——如何在 Haskell 中实现一个容器FIFO，以便您可以快速添加一个新元素并快速从中读取，从旧元素开始？

data Index k = EmptyIndex | PrimIndex k (Index k) | FullIndex (Index k) (Index k) deriving (Show)

{-
*Main> let ind1 = PrimIndex 3 EmptyIndex
*Main> ind1
PrimIndex 3 EmptyIndex
*Main> let ind2 = PrimIndex 4 ind1
*Main> ind2
PrimIndex 4 (PrimIndex 3 EmptyIndex)
*Main> let ind3 = FullIndex ind1 ind2
*Main> ind3
FullIndex (PrimIndex 3 EmptyIndex) (PrimIndex 4 (PrimIndex 3 EmptyIndex))
-}

也就是说，这个想法是相同类型的容器可以是空容器，也可以是基元容器，或者是递归容器的容器。（避免骑自行车）

（可能这里的名字Index不太好，但我觉得代码的意思很清楚）

为了不问两次，我会立即问一个相关的问题，我几乎可以肯定，答案是“不”。从它们用于[]标准列表的意义上说，是否可以为自定义容器（如这个↑）使用“异国情调”括号？

我想创建一个 Container 类，以便不仅用作函数中的参数，例如具有整数键的列表，而且还可以包含任何可以包含值并通过任何比较 ( Eq) 键明确搜索它们的类型.

class Container c where
    at :: (Eq k) => c -> k -> v

当我尝试为同一个列表创建一个类实例时，困难立即开始了（代码不起作用）：

{-
instance Container [a] where
    at lst k = lst !! k
-}

输出以下错误消息：

• Couldn't match expected type ‘Int’ with actual type ‘k’
  ‘k’ is a rigid type variable bound by
    the type signature for:
      at :: forall k v. Eq k => [a] -> k -> v

也就是说，他们说，关键是不够Eq，但显然必须Int按照要求!!。逻辑上，当然！但是，尽管如此，我怎样才能摆脱并实施我的想法呢？

PS 在标准语言的框架内是可取的，没有扩展。

PPS 也需要批评一下问题作者自己给出的答案⬎

-- test1.hs 
-- :l test1
class StampValue sv

class Particle p where
   detect :: (StampValue s) => p -> Int -> s -> Bool

data QValue = R | G | S deriving (Eq)

instance StampValue QValue

data Quantum = Quantum QValue QValue QValue deriving (Eq)

instance Particle Quantum where
   detect _ _ S = error "nonsense" -- Почему нельзя испльзовать S?
-- works: detect _ _ _ = True

理论上，在这个例子中，类型QValue是 StampValue 类的一个实例。在函数detect中，我们只有一个限制器(StampValue s) =>。那么为什么我不能使用这种类型的值S作为模式匹配器呢？

另一个有类似问题的例子：

-- test2.hs 
-- :l test2
class StampValue sv

class Particle p where
   detect :: (StampValue s) => p -> Int -> s -> Bool

type CValue = Bool

instance StampValue Bool -- CValue is an instance of StampValue

data Classical = Classical CValue CValue CValue

instance Particle Classical where
   detect (Classical x _ _) _ False = error "Only True" -- Почему нельзя Bool?
   -- хотя мы задали, что Bool это инстанция StampValue 
   -- (без этой строчки компилится нормально)
   detect (Classical x _ _) 0 _ = x
   detect (Classical _ y _) 1 _ = y
   detect (Classical _ _ z) 2 _ = z
   detect (Classical _ _ _) _ _ = error "the index is out of range"

尝试编译时的ghci消息：

    Couldn't match expected type ‘s’ with actual type ‘Bool’ (или ‘QValue’)
      ‘s’ is a rigid type variable bound by
          the type signature for
            detect :: (StampValue s) => Classical -> Int -> s -> Bool
...

虽然看起来：

cmpSpecial :: (Eq e, Num e) => e -> e -> Bool
cmpSpecial _ 0 = False
cmpSpecial 0 _ = False
cmpSpecial x y = (x == y)

它就是这样工作的，虽然它e也不是这里的类型

几何三维向量的特征在于两个有序的三维点——向量的开始和向量的结束。每个点由三个数字 (x, y, z) 表征。我没记错，我没记错吧？也就是说，要表示一个三维向量，需要六个数字，最好是两个 Point3D 类型，每个包含三个数字。

为什么在《Learn Haskell for the good》一书中，作者只通过三个数字来表示向量的类型？我们当中谁不明白一些事情？

data Vector a = Vector a a a deriving (Show)

这是链接： http: //learnyouahaskell.com/making-our-own-types-and-typeclasses

我有一个与此示例非常相似的简单 C++ ActiveMQ 消息传递客户端。

任务是通过 SSL 连接客户端

收到的文件amq-client_cert.cer（证书）、amq-client.ks（keyStore）、amq-client.ts（trustStore）

根据文档，密钥应采用以下格式.pem

在此处和此处找到如何转换.ks为.pem

我没有找到如何转换.ts为.pem（有必要吗？）

根据文档，代码应如下所示：

System::setProperty( "decaf.net.ssl.keyStore", "<path>/client.pem" );
System::setProperty( "decaf.net.ssl.keyStorePassword", "password" );
System::setProperty( "decaf.net.ssl.trustStore", "<path>/rootCA.pem" );

将 .ks 转换为 .pem 后，我的代码如下所示：

decaf::lang::System::setProperty("decaf.net.ssl.keyStore", "/home/xxx/Keys/sascomm/myapp.pem");
decaf::lang::System::setProperty("decaf.net.ssl.keyStorePassword", "xxx");
decaf::lang::System::setProperty("decaf.net.ssl.trustStore","/home/xxx/Keys/sascomm/amq-client.ts");
decaf::lang::System::setProperty("decaf.net.ssl.trustStorePassword","xxx");

它比我尝试为道具滑动decaf.net.ssl.keyStore文件.ks（消失PEM_read_bio:no start line）但仍然无法连接时变得更好，我只看到一行Error occurred while accessing an OpenSSL library method:然后是一个空行（我显示为CMSException::printStackTrace()）

错误在哪里？怎么办amq-client.ts？谁能给一步一步的指示？或者至少提示在哪里挖掘？

我将一个整数转换为QVariant一个对象QByteArray，以便这个数字有一个字节表示。

我愿意：

#include <QDebug>
#include <QByteArray>
#include <QDataStream>


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    qDebug() << "size of int:" << sizeof(int);
    QVariant var((int)0xF123);
    QByteArray data(sizeof(int),(char)0);
    qDebug() << "data before all:" << data.toHex();

    QDataStream ds(&data,QIODevice::WriteOnly);
    ds << var;

    qDebug() << "size of data:" << data.size();
    qDebug() << "var to binary byte array:" << data./*right(4).*/toHex();

    return 0;
}

在输出我得到：

size of int: 4
data before all: "00000000"
size of data: 9
var to binary byte array: "00000002000000f123"

九个字节而不是四个字节是从哪里来的？

当然，您可以在将类型var发送到 之前显式转换类型QDataStream，如下所示：

ds << var.toInt();

但是在一个真正的程序中，我事先并不知道 in 的类型QVariant，并且我不想switch通过枚举所有可能的数字typeId变量var来做到这一点，而是优雅地做到这一点。

本质上，任务归结为从对象中获取原始数据QVariant及其大小（实际上，大小可以通过 获得typeId，但是你需要用一个长开关检查，值QVariant::type()，此外，要考虑到QMetaType::Int不同的环境它可以有不同的大小，你还必须比较sizeof(int)

PS我发现了一个关于该主题的有趣页面： https ://bugreports.qt.io/browse/QTBUG-35510?page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel&showAll=true

为方便起见，让我们使用 type VariantMap，这样：

typedef QMap<QString, QVariant> VariantMap;

（这是序言）。所以：

1. 我定义了一些自定义容器类型ArgContainer

2. 注册Q_DECLARE_METATYPE：

   Q_DECLARE_METATYPE(ArgContainer)

3. 注册qRegisterMetaType

4. 我在课堂上定义和描述ArgContainer：

   运算符 VariantMap();

因此：

//(далее в примере используется QVariant value с данными ArgContainer)
//1. Вот так работает правильно
{
ArgContainer ac = value.value<ArgContainer>();
VariantMap vm = (VariantMap)ac;
}

//2. А вот так возвращает пустой массив:
{
VariantMap vm = value.value<VariantMap>();
}
//(так дает синтаксическу ошибку VariantMap vm = (VariantMap)value)

最小的工作示例完全在一个文件中：

#include <QCoreApplication>

#include <QDebug>

typedef QMap<QString, QVariant> VariantMap;

class ArgContainer1
{
public:
    operator VariantMap() {
        return QMap<QString, QVariant>({{"test","hey"}});
    }
};
Q_DECLARE_METATYPE(ArgContainer1)

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    ArgContainer1 ac0;
    QVariant value = QVariant::fromValue<ArgContainer1>(ac0);
    //1. Вот так работает правильно
    {
    ArgContainer1 ac = value.value<ArgContainer1>();
    VariantMap vm = (VariantMap)ac;
    qDebug() << "1 value:" << vm.value("test");
    }

    //2. А вот так возвращает пустой массив:
    {
    VariantMap vm = value.value<VariantMap>();
    qDebug() << "2 value:" << vm.value("test");
    }

    return a.exec();
}

控制台执行结果：

1 value: QVariant(QString, "hey")
2 value: QVariant(Invalid)

问题是如何处理ArgContainer使选项 (2) 起作用的类型？ 也就是说，QVariant::value() 函数可以正常工作ArgContainer

也就是说，我们有一个不继承QObject的类：

class Apply
{
    Q_GADGET
    Q_PROPERTY(QVariant func READ func WRITE setFunc)
public:
    Apply();

    QVariant func() const;
    void setFunc(const QVariant &func);

    ArgContainer args() const;
    void setArgs(const ArgContainer &value);

//    void substitute(ArgContainer actualArgs);

private:
    QVariant _func; //func, name of func, name of a registered action
    ArgContainer _args;
};

Q_DECLARE_METATYPE(Apply)

您可以在类中定义属性，如Q_GADGET. 现在如何访问它（不是在 QML 中！）？我这样尝试：

Apply a;
a.property("func");

不property()

我正在尝试访问metaObject：

Apply a;
a.metaObject();

没有这样的东西。

staticMetaObject他们写道：

“staticMetaObject 是 QMetaObject 类型，并提供对使用 Q_ENUMS 声明的枚举的访问。”

它可以用来访问道具吗？如果不是，如何读/写 Q_GADGET 的类属性？

使用哪些现成的库？

即在输入字符串时，不要使用引号并转换为标准JSON，因为已经有现成的库用于解析JSON-on。

直接解析为QMap<QVariant>

注意力！您不需要用于解析正确JSON-a 的库，而是用于解析不正确的行的库JSON-th

例如，这是一个解析普通JSON:

QJsonDocument doc = QJsonDocument::fromJson("[\"a\",\"b\",\"c\"]");
QJsonArray arr = doc.array();
QJsonValue value = arr.at(0);
qDebug() << "value:" << value.toString();

结论：value: "a"

我的情况：

QJsonDocument doc = QJsonDocument::fromJson("[a,b,c]");
QJsonArray arr = doc.array();
QJsonValue value = arr.at(0);
qDebug() << "value:" << value.toString();

结论：value: ""

也就是说，我需要解析字符串"[a,b,c]"而不是"[\"a\",\"b\",\"c\"]"