小编Mar*_*dik的帖子

在这种情况下,静态变量应该只有一个或零个实例.这取决于是否f()被召唤.

void f() 
{
    static int a;
}

但是如果f()是一个方法,那么静态变量有多少个实例呢？

class A
{
    void f()
    {
        static int a;
    }
};

我正在尝试学习如何使用JSON和Qt JSON类.例如,我想创建一个简单的QJsonDocument,将其保存到文件,将其加载到另一个文件QJsonDocument并比较结果.

我成功创造了一个QJsonDocument.但是,QJsonDocument 界面中没有简单的命令将其保存到文件中.这同样适用于加载该文件中的文件.

#include <QJsonObject>
#include <QJsonDocument>
#include <QVariant>

int main()
{
    QVariantMap map;
    map.insert("integer", 1);
    map.insert("double", 2.34);
    map.insert("bool", QVariant(true));
    map.insert("string", "word");
    QJsonObject object = QJsonObject::fromVariantMap(map);

    QJsonDocument document;
    document.setObject(object);

    // ?? save document to file
    // ?? load file to document

    return 0;
}

这个答案显示了如何加载文档

1. 读到一个 QFile
2. 转换QFile为QString
3. 转换QString为QByteArray
4. QJsonDocument从中构建QByteArray

有没有更简单的方法来做到这一点？

考虑一下问题:

我们有一个Base抽象方法的类.现在,我们希望强制执行此方法的每个覆盖都将执行一些参数检查或其他一些苦差事.我们希望这个参数检查在所有覆盖中都是相同的.一种解决方案是将此行为包装在一个非抽象方法中,该方法调用一个抽象方法:

abstract class Base
{
    fun computeSomething(argument: Int): Int
    {
        require(argument > 0) // Some intricate checking
        return execute(argument)
    }

    // Pure functionality, assuming correct arguments
    // Ideally, this would be private. 
    protected abstract fun execute(validArgument: Int): Int
}

class Derived1: Base()
{
    override fun execute(validArgument: Int): Int =
        validArgument * validArgument
}

class Derived2: Base()
{
    override fun execute(validArgument: Int): Int =
        validArgument * validArgument * validArgument
}


fun main(args: Array<String>)
{
    val d = Derived1() …

我通过向spring-boot-starter-data-mongodb-reactiveSpring Boot 项目添加依赖项来使用反应式 MongoDb 驱动程序。升级到 Spring Boot 2.2.x 后出现此错误。

事实证明，如果我做一些简单的事情：

class Something(@Id val name: String)

@Repository
interface SomethingRepository: ReactiveCrudRepository<Something, String>

@SpringBootTest
class DemoApplicationTests
{
    @Autowired protected lateinit var repository: SomethingRepository

    @Test
    fun test()
    {
        repository
            .save( Something("1") )
            .onErrorContinue { throwable, _ -> println(throwable.message) }
            .block()
    }
}

我得到输出：

...
2019-12-12 20:58:48.379  INFO 24425 --- [    Test worker] com.example.demo.DemoApplicationTests    : Started DemoApplicationTests in 2.545 seconds (JVM running for 3.987)
No transaction in context
No transaction in context
... …

我很惊讶地看到这个程序甚至可以编译，但结果更让我惊讶：

import java.util.Collections.swap

fun main(args: Array<String>) 
{
    val immutableList = List(2) { it } // contents are [0, 1] 
    swap(immutableList, 0, 1)
    println(immutableList) // prints [1, 0]
}

该swap函数在库中实现为：

public static void swap(List<?> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }

其中List是可变的 Java 列表，而不是不可变的 Kotlin 列表。所以我认为其他 Java 函数也能工作。例如：

reverse(immutableList)

工作，但其他人，如fill函数，甚至不编译：

fill(immutableList, 3)

产生以下错误消息：

类型推断失败：fun fill(p0: MutableList!, p1: T!): Unit cannot be applied to (List,Int) Type mismatch: inferred type is List but MutableList! …

class Widget;

std::vector< std::shared_ptr<Widget> > container

class Criterium
{
public:
    bool operator()(const Widget& left, const Widget& right)const;
};

如何根据Criterium对容器进行排序,而不是定义另一个标准,如:

class CriteriumForPointers
{
public:
    bool operator()(const std::shared_ptr<Widget>& left, 
                    const std::shared_ptr<Widget>& right)const;
};

在我使用的一个库中,我看到了这段代码:

template<typename T>
void f(SomeTemplatedClass<T> input)
{
    (void)input;
    ...
    use(input); // code that uses input
}

我不知道这段代码的含义是什么.如果我将演员阵容移除为无效,我会得到一个

statement has no effect 

gcc中的警告.所以我想有人故意这样做,故意添加演员以摆脱警告.

您是否对任何无效的陈述有任何经验,但由于某种原因需要它？

编辑:

假设这与模板无关,这是安全的吗？例如绕过旧的编译器错误等？

当我执行以下操作时:

template <typename T>
class Container
{
public:
    class Iterator
    {
        friend bool operator==(const Iterator& x, const Iterator& y);
    };
};

gcc给了我以下警告和建议:

warning: friend declaration 
'bool operator==(const Container<T>::Iterator&, 
                 const Container<T>::Iterator&)' 
declares a non-template function [-Wnon-template-friend]

friend bool operator==(const Iterator& x, const Iterator& y);
                                                           ^

(if this is not what you intended, 
 make sure the function template has already been declared 
 and add <> after the function name here)

我很确定这是一个新的警告,因为我总是这样做,从来没有任何问题.

有人可以解释为什么这是一个警告,它警告什么？

根据包括Wikipedia在内的一些资料，实现二叉树的两种最常用的方法是：

1. 每个节点明确拥有其子节点的节点和指针（或引用）。
2. 子节点的位置由其父节点的索引隐式给出的数组。