ibse's questions

200 条消息使用AES. 原始消息的密文以hex表格形式呈现，大小为 32 或 48 字节（2 或 3 个块）。可用密文示例：

4d0f16f795b1030b6e7a8225b73c04298858d4105a46d0f1f252d27516250271

174c446891db6a795c6ee73c56113c50461203ed49a52b316b3e0d628fd3e1ae01483c7fbf6bb40d14066dfcde3b5445

d4764bfc460588bd889981fbf9475c73f23f8f882ef65f6f79d1883c9658dcc3

上面是 3 个不同的密文，大小分别为 32、48、32 字节。

众所周知，在所有 200 条消息中，只有一条在ECB (Electronic Codebook). 您需要在其余部分中找到此消息的密文。

我发现密文中有完全相同的对。例如：

4d0f16f795b1030b6e7a8225b73c04298858d4105a46d0f1f252d27516250271和4d0f16f795b1030b6e7a8225b73c04298858d4105a46d0f1f252d27516250271

3f1070a120005f5f9e20c91e078e8e1c0f5d7c88fa2f7e8ee6b7b4837d7f652746177a9b4ea445405cb7c326b9ec4ce8和

3f1070a120005f5f9e20c91e078e8e1c0f5d7c88fa2f7e8ee6b7b4837d7f652746177a9b4ea445405cb7c326b9ec4ce8

这意味着它们是通过ECB? 毕竟，ECB相同的明文块被加密成相同的密文块。但是条件说只有一条这样的线路，而这里已经至少有 4 年了。

一般来说，如何找到答案？往哪个方向移动？

我创建了一个本地存储库并将其上传到 GitHub：

$ git init
$ git add .
$ git commit -m "f"
$ git branch dev
$ git checkout dev
$ git add .
$ git commit -m "s"
$ git checkout master
$ git remote add origin https://github.com/Zhukovdpua/1.git
$ git push -u origin master

现在如何查看那里的开发分支的内容？我只看到大师 https://github.com/Zhukovdpua/1

有必要根据调用的重载push_back（左值或右值）调用相应的构造函数（复制或移动）：

struct tmpS {
    tmpS() {}
    tmpS(const tmpS& s) {
        std::cout << "copy\n";
    }
    tmpS(tmpS&& s) {
        std::cout << "move\n";
    }
};

template<typename Type>
void pass_to_construct(Type&& arg) { // универсальная ссылка
    tmpS t = std::forward<Type>(arg);
}

template<typename T>
struct v {
    v() {}
    void push_back(T&& value) { // вызовется эта перегрузка
        pass_to_construct(value);
    }

    void push_back(const T& value) {
        pass_to_construct(value);
    }

};

int main()
{
    v<tmpS> s;
    s.push_back(tmpS()); // rvalue
}

上面的代码调用复制构造函数（打印副本）。为什么不动？

啊文件：

#pragma once
#include "B.h"

template<class T>
struct A {
    A(B<T>& p);
};

template<class T>
A<T>::A(B<T>& p) {

}

bh文件：

#pragma once
#include "A.h"

template<class T>
struct B {
    B(A<T>& p);
};

template<class T>
B<T>::B(A<T>& p) {

}

main.cpp 文件：

#include "A.h"
#include "B.h"

int main() {
    return 0;
}

错误：

您需要询问用户的输入。如果他输入“ls”，那么你需要打印“one”，如果“sh” - “two”

let mut guess = String::new();

io::stdin().read_line(&mut guess)
    .expect("Не удалось прочитать строку");

let sh="sh".to_string();
let ls="ls".to_string();

match guess {
    ls => println!("один"),
    sh => println!("два"),
 }

为什么无论用户输入什么，这段代码都会打印“一”？

结构中有一个包含 100 个元素的数组：

struct S{
    state: [i32;100],
}

您需要在构造函数中填充从 1 到 100 的数字序列：

impl S{
    fn new() -> S{
        // что должно быть здесь?
    }
}

什么是实现继承，为什么private继承称为实现继承？

struct S {};

有什么区别

S s;
S* s_ptr = new S;

和

S s();
S* s_ptr = new S();

?

struct P1 {
    virtual void f() {} // Функция 1
};

struct P2 {
    virtual void f() {} // Функция 2
};

struct D :P1, P2 {
    void f() override {} // Здесь переопределяется функция 1 или функция 2?
};

为什么上面的代码没有抛出类似“ambiguous redefinition”这样的编译错误？

编译器如何确定要在D P1::f()or中覆盖什么P2::f()？

struct A {
    virtual void f(){}
};

struct B1: virtual A {
    virtual void f() {}
};

struct B2 : virtual A {
    virtual void f() {}
};

struct C :B1,B2 {

};

错误 C2250 C：不明确的继承“void A::f(void)”。这是什么意思？

为什么上面的代码对我有用而没有错误？

int* func() {
   int var = 100;
   return &var;
}


int main()
{
    int* ptr = func();
    cout << *ptr; // печатает 100, хотя здесь я ждал ошибки или неопределённого поведения, ведь var должна быть уже удалена к этому моменту
}

我将地址返回到var应该在退出时删除的局部变量func()，但我仍然可以访问它（cout << *ptr;）

我按顺序进行 2 次提交，根据我切换到的提交，git log它会给出不同的输出。

我做的工作目录中有一个文件main.txt ：

$ git add main.txt 
$ git commit -m 'first commit'

然后我更改内容main.txt并再次提交：

$ git add main.txt 
$ git commit -m 'second commit'

现在，据我了解，我有 2 次提交的历史记录。如果你git log现在这样做，它真的会打印 2 个提交并HEAD指向我当前所在的提交：

$ git log
commit 43d08e5d2a2508d913ff4550ac5c6b51b190603e (HEAD -> master)
Author: User <user@company.com>
Date:   Thu Dec 19 16:24:07 2019 +0300

    second commit

commit 8515c37a95ed127b27f8637d0ee5a1de887281e3
Author: User <user@company.com>
Date:   Thu Dec 19 16:22:35 2019 +0300

    first commit

但是，如果您切换到上一个提交（第一次提交）：

$ git checkout 8515c37a95ed12

现在输出git log将只包含 1 个提交：

$ git log
commit 8515c37a95ed127b27f8637d0ee5a1de887281e3 (HEAD)
Author: User <user@company.com>
Date:   Thu Dec 19 16:22:35 2019 +0300

    first commit

虽然在这里我也希望看到 2 个提交

应该是这样吗？如果是这样，并且git log它确实没有显示所有提交和所有历史记录，那么无论我正在进行什么提交，我如何找出答案？

有 2 个线程 ( a, b) 和 1 个互斥锁。互斥锁已由其他线程拥有（nota和 not b）。线程a既b执行lock()又等待互斥体。

释放互斥锁时，线程将按什么顺序访问互斥锁a？b例如，如果线程是第一个锁定（执行lock()）a，然后b，线程应该先进入，然后再进入a，b还是不一定？

我无法处理内存障碍的话题。什么时候，哪些线程，以什么顺序更新共享变量的值？

bool flag = false;

void f1() {
    flag = true;
}

void f2() {
    cout << flag << endl;
}

int main() {
    thread FIRST_THREAD(f1); //Первый поток
    thread SECOND_THREAD(f2); //Второй поток

    FIRST_THREAD.join();
    SECOND_THREAD.join();
}

是否会发生在第一个线程执行f1()后更改flag为true第二个线程执行f2()后读取旧值flag并打印false？

如果是这样，应该如何设置内存屏障来避免这种情况？所以？：

void f1() {
    atomic_thread_fence(memory_order_release);
    flag = true;
}

void f2() {
    cout << flag << endl;
    atomic_thread_fence(memory_order_acquire);
}

它与以下有何不同：

void f1() {
    atomic_thread_fence(memory_order_seq_cst);
    flag = true;
}

void f2() {
    cout << flag << endl;
    atomic_thread_fence(memory_order_seq_cst);
}

据我所知，该变体release/acquire比seq_cst. “较弱”是什么意思？

升级版：

@Andrej Levkovitch，首先，我自己不知道我的问题是否有问题，所以我问的第一件事是“会不会是……？” 找出是否有问题。我马上会注意到，问题不在于flag通过互斥锁、原子变量等同步访问。在我描述的假设线程执行场景中，默认情况下会发生访问同步flag：第一个线程总是flag在第二个线程读取之前写入flag。问题不同：第一个线程能否将值更改flag为，之后true的第二个线程（即有同步）不更新其值并读取旧值flagfalse. “在家”是指（虽然我不确定我在这里写的是什么）线程正在运行的处理器内核的缓存。

这里有张桌子：

CREATE TABLE "test" (
    "Field1"    INTEGER,
    "Field2"    INTEGER
);

需要在向表中插入行时，如果第一个字段中的值小于第二个字段中的值，则取消插入。

例如：

INSERT INTO test VALUES(1,4); Вставка должна отмениться, поскольку 1-ое поле меньше 2-ого

INSERT INTO test VALUES(4,1); Здесь вставка должна пройти успешно

据我了解，您需要制作一个 BEFORE INSERT 触发器。然后怎么做？

这里有张桌子：

CREATE TABLE "test" (
    "Field1"    TEXT
);

接下来，我创建一个触发器：

CREATE TRIGGER t1 AFTER INSERT
ON test
BEGIN
SELECT* from test
END;

但我收到一个错误：结果：第 1 行的输入不完整

为了创建数据库和编写查询，我使用DB Browser for SQLite

有表演。需要在按下鼠标按钮时接收事件或信号，其中将包含鼠标按下的元素的索引和鼠标坐标。

当鼠标悬停在视图中的条目上时按下鼠标按钮时，视图会发出一个void pressed(const QModelIndex &index)信号。如果您在视图中定义鼠标事件处理程序mousePressEvent（其中包含按下按钮的坐标），那么它将需要所有鼠标点击，并且不会发出按下的(const QModelIndex &index)信号。

class ListView : public QListView
{
    Q_OBJECT

public:
    ListView() {
        connect(this, SIGNAL(pressed(const QModelIndex &)), this,         
                SLOT(getIndex(const QModelIndex &)));
    }

    void mousePressEvent(QMouseEvent* event) {
        qDebug() << event->x() << event->y();
    }

public slots:
    void getIndex(const QModelIndex & index) {
        qDebug() << index.row();
    }
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QStringList list;
    list << "a" << "b" << "c";

    QStringListModel model;
    model.setStringList(list);

    ListView view;
    view.setModel(&model);
    view.show();

    return app.exec(); 
}

实际上，如何确保在视图上按下鼠标按钮时，会捕获包含单击坐标和元素索引的信号或事件？

我需要画一个圆，类似于图片中的内容（以便在 3/4 处绘制圆，使弦平行于 X 轴）：

我使用 drawChord() 方法，开始角度为 315，结束角度为 225：

int startAngle = 315 * 16; 
int spanAngle = 225 * 16;
painter.drawChord(QRect(10, 10, 100, 100), startAngle, spanAngle);

我知道弦不平行于X轴

可能，我没有正确理解参数 startAngle、spanAngle 的含义？

有两个类具有彼此的实例：

啊文件

#pragma once
#include "B.h"

class A
{
public:
    B b;
    A();
   ~A();
};

文件_

#pragma once
#include "A.h"

class B
{
public:
    A a;
    B();
   ~B();
};

.cpp文件

#include "A.h"

A::A()
{
}

A::~A()
{
}

B.cpp文件

#include "B.h"

B::B()
{
}


B::~B()
{
}

您需要声明和初始化unique_ptr. 它必须指向一个结构。

struct Node {
    int key;
};

unique_ptr<Node> head;
head = make_unique<Node>(new Node);

错误：

Node::Node(Node &&): невозможно преобразовать аргумент 1 из "_Ty" в "const Node &