megorit

Перепутал конъюнкцию с дизъюнкцией:

const int  x = 7;
const bool A = true;
const bool B = false;

std::cout << std::boolalpha
          << A && B || !(x*x < 12 && 2*x <= 5) || std::exp(x-1) > 7
          << std::endl;

Благодаря такой штуке как upcasting, ссылки и указатели на производные классы к базовому можно не приводить явно. Потому что базовый класс является подмножеством производного, и это как бы не нарушает логику.

Компиляция немного замедлится (но ты этого не заметишь), а выполнение, конечно же, нет.
Порой без auto не обойтись (в шабонных функциях с decltype, со структурными привязками, с лямбдами...), но часто код просто короче и читаемее.

Да, в Python динамическая типизация (т.е. полный срач), а в C++ - нет. В С++ есть динамическое связывание (для виртуальных методов), есть RTTI, но это совсем разные вещи.

Питон работает медленно, потому что он не компилируемый, а интерпретируемый. Т.е. он каждый раз компилируется "на лету".

В общем, самый нормальный способ - создать std::set<fs::path> и заполнить его содержимым, а затем воспользоваться реверсивным итератором std::set.

std::set<fs::path> file_paths;

for (const auto& dir_entry : fs::directory_iterator{"path/to/directory"})
    file_paths.insert(dir_entry.path());

auto iter = file_paths.rbegin();
auto end = file_paths.rend();

name.erase(name.find_first_of(" "));

но лучше так

int index = 0;
for (const auto ch : name)
    if (ch == ' ') { name.erase(index); break; }
    else ++index;

Нашёл вот что:

Для решения этих проблем придумали std::initializer_list — "магический класс", который представляет собой очень легкую обертку для массива элементов известного размера, а так же умеет конструироваться от braced-init-list-а. Почему же он "магический"? Как раз по описанным выше причинам его невозможно эффективно сконструировать в пользовательском коде, поэтому компилятор создает его специальным образом.

Подключил таким образом:

• добавил каталог собранной библиотеки в каталог проекта
  
• открыл CMakeLists.txt в своём проекте и дописал:
  

  target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/path_to_include_dir)
  target_link_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/path_to_link_dir)
  target_link_libraries(${PROJECT_NAME} PUBLIC libname)

  
  

Нужно было создавать виджеты нижнего уровня внутри класса виджета верхнего уровня. Версия 2.0:
main

#include <QtWidgets>
#include "widget.h"

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

    Widget ConverterWeights;
    ConverterWeights.show();

    return ThisApp.exec();
}

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QtWidgets>

class Widget : public QWidget
{
Q_OBJECT

public:
    QLabel      *Title;
    QLineEdit   *Input;
    QLineEdit   *Output;
    QComboBox   *UnitWI;
    QComboBox   *UnitWO;
    QPushButton *Button;

public:
    Widget() : QWidget()
    {
        Title   = new QLabel(this);
        Input   = new QLineEdit(this);
        Output  = new QLineEdit(this);
        UnitWI  = new QComboBox(this);
        UnitWO  = new QComboBox(this);
        Button  = new QPushButton(this);

        ConfigBase();
        ConfigTitle();
        ConfigInput();
        ConfigOutput();
        ConfigUnitWI();
        ConfigUnitWO();
        ConfigButton();

        QObject::connect(Button,SIGNAL(clicked(bool)),this,SLOT(PushButton()));
    }
    ~Widget() {}

private:
    void ConfigBase();
    void ConfigTitle();
    void ConfigInput();
    void ConfigOutput();
    void ConfigUnitWI();
    void ConfigUnitWO();
    void ConfigButton();

public slots:
    void PushButton()
    {
        /*code*/
    }
};

#endif

Решил. Создаем объекты:

QLabel      Title;
QLineEdit   Input;
QLineEdit   Output;
QComboBox   UnitWI;
QComboBox   UnitWO;
QPushButton Button;

и затем устанавливаем родителя методом setParent().

Но как оказалось, выделение памяти на стеке для виджетов - очень плохая затея.
Связанно это с переполнением стека и с тем, что при создании нескольких несвязанных иерархией виджетов приведет к ошибке (исключению).