Имя Фамилия's questions

我的问题的关键在于，当在 C++ 中分配基本类型的动态数组时，其默认值被初始化为零，例如：

int* array = new int[size];

将创建一个动态的size零数组。

有几个问题：

1. new[]当使用没有显式初始化器的运算符时，C++ 标准是否保证动态分配的数组的元素将初始化为零？
2. 动态数组分配的各种实现中的程序是否花费时间将元素初始化为零？
3. 如果我关心最大性能并计划立即覆盖所有数组元素，是否有一种方法可以在 C++ 中分配动态数组，从而避免初始化时间？

我编写了一个小型测试项目来演示我的问题。

重点是，根据 的官方文档来看qt_add_translations，我在下面给出的两个代码应该大致相同。qt_add_lupdate那么，根据函数、qt_add_lrelease和的含义qt_add_resources，翻译文件必须添加到可执行文件中。

但由于某种原因，在使用时，второго варианта翻译文件没有添加到可执行文件中。

cmake_minimum_required(VERSION 3.27)
set(CMAKE_CXX_STANDARD 23)

project(TestQtWidgetsProject)

set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)

# Executable
add_executable(${PROJECT_NAME} main.cpp)

# Library
find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)
target_link_libraries(${PROJECT_NAME} Qt::Core Qt::Gui Qt::Widgets)

# Translations
find_package(Qt6 REQUIRED LinguistTools)

# =======================================

# Variant 1

#qt_add_translations(TestQtWidgetsProject
#        INCLUDE_DIRECTORIES
#            ${PROJECT_SOURCE_DIR}
#        TS_FILES
#            translation_ru.ts)

# Variant 2

qt_add_lupdate(${PROJECT_NAME} INCLUDE_DIRECTORIES ${PROJECT_SOURCE_DIR} TS_FILES translation_ru.ts)
qt_add_lrelease(${PROJECT_NAME} TS_FILES translation_ru.ts QM_FILES_OUTPUT_VARIABLE QM_FILES)
qt_add_resources(${PROJECT_NAME} "translations" PREFIX "/i18n" FILES ${QM_FILES})

# =======================================

# Dependencies
add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}_lupdate)
add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}_lrelease)

main.cpp

#include <QApplication>
#include <QPushButton>
#include <QTranslator>

int main(int argc, char* argv[]) {
    QApplication a(argc, argv);
    QTranslator translator;

    qDebug() << translator.load(":/i18n/translation_ru");
    qDebug() << QApplication::installTranslator(&translator);

    QPushButton button(QApplication::tr("Hello, World!") + QApplication::tr(" qwe"), nullptr);
    button.resize(200, 100);
    button.show();
    return QApplication::exec();
}

使用第一个选项时的输出：

true
true

使用第二个选项时的输出：

false
false

有一个文件，比如说example_file，二进制文件。

我想将其中所有出现的字符串替换example_str为相应的零字节序列（\0），也就是说，出现的每个字符都被零字节替换。（指定\0\0\0\0\0\0\0\0\0\0\0这不是一个选项，因为（1）它很不方便，（2）我想对不同的线路多次使用此命令）

什么bash命令可以做到这一点？我希望它尽可能简短。

有这样的代码：

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

    QTranslator translator;
    const QString dir = "/usr/share/qt6/translations";

    if (translator.load("qt_ru", dir)) {
        QApplication::installTranslator(&translator);
        qDebug() << QApplication::translate("QShortcut", "Open");
        qDebug() << QApplication::tr("Open");
    }

    ...
}

他的结论是：

"Открыть"
"Open"

为什么在第二种情况下“Open”这个词没有被翻译？

我正在用 JavaFX 编写一个矢量画布（矢量图形，只显示画布上的形状）：好吧，这样您就可以四处移动并放大它。
由于随着 translate 节点左上角的位置发生变化，它不再响应点击，我决定在画布本身内部制作一个面板，所有内容都将显示在上面。
里面VectorCanvas是VectorCanvasContent。
添加了行VectorCanvasContent，但由于某种原因它们不可见（尽管它们是可见的，但我添加了一个侦听器，在单击它们时显示“!!!”并选中）。
如果您在画布本身上绘制线条，则它们是可见的。
问题是什么？

public class VectorCanvas extends Pane {


    public class VectorCanvasContent extends Pane {


//        public final ChangeListener<Number> widthChangeListener
//                = (observable, oldValue, newValue) -> setWidth(newValue.doubleValue());
//        public final ChangeListener<Number> heightChangeListener
//                = (observable, oldValue, newValue) -> setHeight(newValue.doubleValue());


        public VectorCanvasContent() {
//            VectorCanvas.this.widthProperty().addListener(widthChangeListener);
//            VectorCanvas.this.heightProperty().addListener(heightChangeListener);
//            widthProperty().addListener((observable, oldValue, newValue)
//                    -> System.out.println("Content: width: " + newValue));
//            heightProperty().addListener((observable, oldValue, newValue)
//                    -> System.out.println("Content: height: " + newValue));
        }
    }


    public static final Consumer<VectorCanvas> DEFAULT_DRAWER = canvas -> {
        Line[] lines = {
                new Line(0, 0, canvas.getWidth(), 0),
                new Line(canvas.getWidth(), 0, canvas.getWidth(), canvas.getHeight()),
                new Line(canvas.getWidth(), canvas.getHeight(), 0, canvas.getHeight()),
                new Line(0, canvas.getHeight(), 0, 0),
                new Line(0, 0, canvas.getWidth(), canvas.getHeight()),
                new Line(0, canvas.getHeight(), canvas.getWidth(), 0)
        };
        for (Line line : lines) {
            line.setStrokeWidth(30);
            line.setStroke(Color.RED);
            line.setFill(Color.RED);
            line.setOnMouseClicked(new EventHandler<MouseEvent>() {
                @Override
                public void handle(MouseEvent mouseEvent) {
                    System.out.println("!!!");
                }
            });
        }
        canvas.drawAll(lines);
    };

    private Consumer<VectorCanvas> drawer = DEFAULT_DRAWER;

    public final VectorCanvasContent content = new VectorCanvasContent();


    public VectorCanvas() {
        this(DEFAULT_DRAWER);
    }

    public VectorCanvas(Consumer<VectorCanvas> drawer) {
        this.drawer = drawer;
        getRealChildren().add(content);
        draw();
    }


    public void clear() {
        getChildren().clear();
    }
    public void draw() {
        if (drawer != null)
            drawer.accept(this);
    }
    public void redraw() {
        clear();
        draw();
    }


    @Override
    public ObservableList<Node> getChildren() {
        return content.getChildren();
    }
    @Override
    public ObservableList<Node> getChildrenUnmodifiable() {
        return content.getChildrenUnmodifiable();
    }


    private ObservableList<Node> getRealChildren() {
        return super.getChildren();
    }
    private ObservableList<Node> getRealChildrenUnmodifiable() {
        return super.getChildrenUnmodifiable();
    }


    public void draw(Shape shape) {
        getChildren().add(shape);
    }
    public void drawAll(Shape... shapes) {
        getChildren().addAll(shapes);
    }
}

在应用程序中，我右键单击框架顶部，选择“高级”-“无框架”。
我怎样才能找回框架？

如何制作这样的桌子LaTeX？

底线是第一列和最后一列的宽度应该对齐。
中间的单元格应如下所示：在第一列和第二列之间的前两行中，有五个相同宽度的单元格，在第三行 - 四个，最后两行 - 也是五个。

照片表达了桌子的结构。

根据多次测量的结果计算有误差的量值的表。

例如，我编写了以下类：

class TestClass {
public:
    char v(const string &str) const {
        return str[0];
    }
};

编译器希望我v用[[nodiscard]]. 为什么？

我试图Predicate在Javaon中写一个类的类似物C++。结果，一些肮脏的东西出来了：

template <typename T>
class Predicate {

private:

    Predicate<T> *other;

public:

    virtual bool test(T &t) = 0;

    Predicate<T> AND(Predicate<T> other);

    Predicate<T> OR(Predicate<T> other);

    Predicate<T> negate();
};

template<typename T>
Predicate<T> Predicate<T>::AND(Predicate<T> other) {
    Predicate<T> *t = this;
    class TmpPredicate : Predicate {

        TmpPredicate() {
            this->other = other;
        }

        bool test(T &t) {
            return t->test(t) && other.test(t);
        }
    };
    return TmpPredicate();
}

其余功能尚未实现。

总的来说，这一切都很糟糕，但我不知道如何正常进行。你能建议吗？

按照计划，这个类应该像Predicate. Java理想情况下，您不需要分配动态内存来使用它，使用动态内存应该Predicate在其内部实现中实现。

例子：

int main() {
    Predicate<char> p([](char c) { return c == 'A'; });
    Predicate<char> p2([](char c) { return c == 'B'; });
    cout << p('b') << '\n'; // 0
    cout << p.NOT()('a') << '\n'; // 1
    cout << p.AND(p2)('A') << '\n'; // 0
    cout << p.OR(p2)('B') << '\n'; // 1
    cout << p.OR(p2).OR(p)('A') << '\n'; // 1
    cout << p.OR(p2).OR(p).OR(p2)('a') << '\n'; // 0
}

如果是TeX这样Unicode，那么为什么需要安装额外的软件包才能使用某些语言，为什么它们的重量从 50 兆字节到超过 1 吉字节？

为什么在程序中 onC和C++onLinux任何字符串都按应有的方式显示，但Windows必须调用setlocaleon 方法才能正确显示某种语言的字符串？

我怎样才能使它在启动具有 的 Activity 或 Fragment 时，EditText与其关联的键盘会自动打开EditText？

主要活动：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        EditText editText = findViewById(R.id.edittext);
        editText.requestFocus();
    }
}

活动主.xml：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <EditText
        android:id="@+id/edittext"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:inputType="number"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

我正在使用操作系统Kali Linux。
试图直接将手机连接到Android Studio和ADB。
USB 调试模式已启用。
以下是来自的截图Android Studio：

Android Studio 看到了手机，但 ADB 不想看到它：

这是与adb：

user@kali:~$ adb devices
List of devices attached

user@kali:~$ adb kill-server 
user@kali:~$ adb start-server 
user@kali:~$ adb devices 
List of devices attached

user@kali:~$ adb kill-server 
user@kali:~$ adb start-server 
* daemon not running; starting now at tcp:5037
* daemon started successfully
user@kali:~$ adb devices 
List of devices attached

user@kali:~$ 

lsusb看到设备。

我试图修改文件/etc/udev/rules.d/51-android.rules，尝试了其他东西，但没有取得任何成果。

环境变量存储在哪里Linux，更具体地说，存储在哪里Kali Linux？

更具体地说，当我在我的这一行中使用 java 相关程序时，如何删除_JAVA_OPTIONS弹出的变量
Picked up _JAVA_OPTIONS: -Dawt.useSystemAAFontSettings=on -Dswing.aatext=true？
当然，我可以写入unset _JAVA_OPTIONS文件.bashrc，但这个解决方案是一个 hack，我不喜欢它。

编写了一个汇编nasm程序以将标准输入流中包含的所有内容输出到标准输出流。

global _start

section .bss

char    resb 1

section .text

_start: mov eax, 3      ; номер системного вызова read
        xor ebx, ebx    ; из стандартного потока ввода
        mov ecx, [char] ; читаем в область памяти, обозначенную char
        mov edx, 1      ; читаем один байт
        int 0x80        ; вызываем read
        cmp eax, 1      ; смотрим, сколько символов прочиталось
        jnz exit        ; если не 1 (то есть 0), то выходим
        mov eax, 4      ; номер системного вызова write
        mov ebx, 1      ; в стандартный поток вывода
        mov ecx, [char] ; читаем из области памяти, обозначенной char
        mov edx, 1      ; читаем один байт
        int 0x80        ; вызываем write
        jmp short _start ; делаем всё заново
exit:   mov eax, 1      ; номер системного вызова _exit
        xor ebx, ebx    ; код 0
        int 0x80        ; вызываем _exit

但是由于某种原因，当我尝试使用它时，我得到了这个：

user@kali:~$ ./myprogramm
12345
user@kali:~$ 12345
bash: 12345: команда не найдена
user@kali:~$ 

当我尝试对文件执行相同操作时，即我 write .myprogramm < input.txt > output.txt，output.txt结果是空的。

创建了两种计算斐波那契数的方法：一种使用普通递归，另一种使用ForkJoinPool(ом). 问题是该方法fibonacci1比fibonacci. 请解释原因。一般如何使用ForkJoinPool(ом)？

public class MyRecursiveAction extends RecursiveTask<Long> {

    private static ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();

    public static void main(String[] args) {
        long l1, l2;
        l1 = System.nanoTime();
        fibonacci1(40);
        l2 = System.nanoTime();
        System.out.println(l2 - l1);
        l1 = System.nanoTime();
        fibonacci(40);
        l2 = System.nanoTime();
        System.out.println(l2 - l1);
    }

    private long n;

    private MyRecursiveAction(long n) {
        this.n = n;
    }

    public static long fibonacci(long n) {
        return forkJoinPool.invoke(new MyRecursiveAction(n));
//        return new MyRecursiveAction(n).invoke();
    }

    public static long fibonacci1(long n) {
        if (n == 0 || n == 1)
            return n;
        if (n > 0)
            return fibonacci1(n - 1) + fibonacci1(n - 2);
        else
            return fibonacci1(n + 2) - fibonacci1(n + 1);
    }

    @Override
    protected Long compute() {
        if (n == 0 || n == 1)
            return n;
        if (n > 0) {
            MyRecursiveAction myRecursiveAction1 = new MyRecursiveAction(n - 1);
            forkJoinPool.invoke(myRecursiveAction1);
//            myRecursiveAction1.fork();
            MyRecursiveAction myRecursiveAction2 = new MyRecursiveAction(n - 2);
            forkJoinPool.invoke(myRecursiveAction2);
//            myRecursiveAction2.fork();
//            return myRecursiveAction1.join() + myRecursiveAction2.join();
            return myRecursiveAction1.join() + myRecursiveAction2.join();
        } else {
            MyRecursiveAction myRecursiveAction1 = new MyRecursiveAction(n + 1);
            forkJoinPool.invoke(myRecursiveAction1);
//            myRecursiveAction1.fork();
            MyRecursiveAction myRecursiveAction2 = new MyRecursiveAction(n + 2);
            forkJoinPool.invoke(myRecursiveAction2);
//            myRecursiveAction2.fork();
//            return myRecursiveAction2.join() - myRecursiveAction1.join();
            return myRecursiveAction2.join() - myRecursiveAction1.join();
        }
    }
}

有用：

map<int, bool>* m = new map<int, bool>;
delete (m + 0);  

这不起作用：

map<int, bool>* ms = new map<int, bool>[4];
delete (ms + 0); // для примера удаляю только первый элемент, а не весь массив

为什么？

我需要set按它们在数组中指向的元素对数字进行排序。怎么做？

template<>
class set<int> {

    int* arr;

public:
    set(int* arr) : arr(arr) {

    }

    // какой-то метод надо переопределить?
};

我试图在声明二维数组时初始化它的所有元素：

int** ints = new int* [n] { new int[n] { 0 } };

尝试显示项目时

for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cout << "i = " << i << "; j = " << j << "; value = " << ints[i][j] << endl;

我在控制台中得到这个结果：

i = 0; j = 0; value = 0
i = 0; j = 1; value = 0
i = 0; j = 2; value = 0
i = 1; j = 0; value =

抛出异常：нарушение прав доступа при чтении по адресу 0x0000000000000000。

我不知道发生了什么事。

n = 3.

当显示初始化如下的一维数组的元素时：

int* ints = new int[5];

输出到控制台

-842150451
-842150451
-842150451
-842150451
-842150451

，但像这样：

int* ints = new int[5] { 0 };

-

0
0
0
0
0

.

String举个例子。

String[][] strings = (String[][])new Object[10]发出ClassCastException。请解释原因。

在这方面，泛型存在一个问题：

有一个示例类：

class GenericClass<G> {
    G[] value;

    GenericClass(G[] value) {
        // так как создать массив из G нельзя (new G[]),
        // приходится делать массив из Object(ов)
        this.value = (G[])new Object[value.length]; // создание нового массива из обджектов всё рушит
        System.arraycopy(value, 0, this.value, 0, value.length);

        // this.value = value; работает
    }
}

这是有问题的代码：

GenericClass<String[]> genericClass = new GenericClass<>(
        new String[][] {
                new String[] {"f", "s", "t"},
                new String[] {"1", "2", "3"},
                new String[] {"п", "в", "т"}});

String[][] strings = genericClass.value; // ClassCastException (именно в этой строчке)

不知何故，这个问题在ArrayList. 我不明白怎么做。通常有一个对象数组，并且一切正常。