Author Archives: dmitriano

Building QT6.4 with OpenSSL for Windows – iteration #1

I build it with similar commands as I used before for Building QT 6.3.1 with OpenSSL for Windows. The only difference was that I added -static-runtime option and skipped qtquick3dphysics and qtspeech modules:

"C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvarsall.bat" amd64
   
set "CMAKE_ROOT=C:\dev\PFiles\cmake-3.24.0-rc4-windows-x86_64\bin"
set "NINJA_ROOT=C:\dev\PFiles\ninja-win"
set "PERL_ROOT=C:\dev\PFiles\Strawberry\perl\bin"
   
set PATH=%CMAKE_ROOT%;%PATH%
set PATH=%NINJA_ROOT%;%PATH%
set PATH=%PERL_ROOT%;%PATH%
set PATH=C:\dev\PFiles\Python35;%PATH%
   
rem Check if the tools are in PATH
where perl.exe
where python.exe
where cmake.exe
where ninja.exe
   
set "MY_INSTALL_PATH=C:/dev/libs/Qt6.4/windows"
set CL=/MP
 
configure.bat -prefix %MY_INSTALL_PATH% -DQT_NO_EXCEPTIONS=1 -debug-and-release -force-debug-info -platform win32-msvc -opensource -confirm-license ^
-c++std c++20 -static -static-runtime -I "C:/Program Files/OpenSSL/include" -L "C:/Program Files/OpenSSL/lib" -openssl-linked ^
  -skip qt3d -skip qt5compat -skip qtactiveqt -skip qtcharts -skip qtcoap -skip qtconnectivity ^
  -skip qtdatavis3d -skip qtdoc -skip qtlottie -skip qtmqtt -skip qtnetworkauth -skip qtopcua ^
  -skip qtserialport -skip qtpositioning -skip qtquicktimeline -skip qtquick3d -skip qtremoteobjects ^
  -skip qtscxml -skip qtsensors -skip qtserialbus -skip qtvirtualkeyboard -skip qtwayland ^
  -skip qtwebchannel -skip qtwebengine -skip qtwebview -skip qttools -skip qttranslations -skip qtquick3dphysics -skip qtspeech
(more…)

Converting WAV files with Sox

Source file:

soxi short-borrowed-old.wav
Input File     : 'short-borrowed-old.wav' (flac)
Channels       : 2
Sample Rate    : 44100
Precision      : 16-bit
Duration       : 00:00:00.60 = 26460 samples = 45 CDDA sectors
File Size      : 54.0k
Bit Rate       : 720k
Sample Encoding: 16-bit FLAC
Comment        : 'Comment=Processed by SoX'
(more…)

Throwing an exception from a function parameter in C++

There is no difference between lines 82 and 92 in the code below with both MSVC2022 and GCC11:

#include <utility>
#include <stdexcept>
#include <iostream>

struct Object
{
    virtual const char* name() = 0;

    virtual ~Object() = default;
};

struct A : public Object
{
    const char* name() override
    {
        return "A";
    }
};
(more…)

The rule of three/five/zero in C++

Using std::shared_ptr in QML

QT is developed by an alien civilization that hate humans. They can’t make std::shared_ptr work in QML since 2014:

(more…)

static_cast can’t convert from a virtual base class in C++

It converts only from non-virtual base class subobject:

struct B
{
    virtual ~B() {};
};

struct D : public virtual B { };

int main()
{
    D d;
    B& br1 = d;

    // cannot convert a 'B*' to a 'D*'; conversion from a virtual base class is implied
    // static_cast<D&>(br1); 

    dynamic_cast<D&>(br1);

    return 0;
}

Storage duration and linkage in C++

In the vernacular they say stack and heap, but the standard call this automatic and dynamic:

(more…)

QT signal performance significantly degrades when the number of the connections grow.

In my previous post I compared the performance of a single QT connection with the performance of a notification mechanism based on virtual functions.

In this post I’ll demonstrate how the performance of QT signals degrade when the number of the connections grow. Briefly saying a QT signal becomes 57 times slower than a virtual function.

Below I described my experimentations and provided the full source code.

(more…)

QT signal is ten times slower than a virtual function

I defined a QT Object that contains an integer value and uses QT signal along with awl::Observable based on virtual functions to notify the subscribers when the value changes:

#include "Awl/Observable.h"

#include <QObject>

namespace test
{
    class NotifyValueChanged
    {
    public:

        virtual void onValueChanged() = 0;
    };
    
    class ValueObject : 
        public QObject,
        public awl::Observable<NotifyValueChanged>
    {
        Q_OBJECT

    public:

        Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)

        void notifyValueChanged()
        {
            Notify(&NotifyValueChanged::onValueChanged);
        }

    signals:

        void valueChanged();

(more…)

How we use forwarding references with ranges in C++

The parameter or print function is a forwarding reference because the range can change while being iterated, but the current value is l-value reference:

#include <string>
#include <vector>
#include <ranges>
#include <iostream>

template <class R, class Value>
concept range_over = std::ranges::range<R> &&
    std::same_as<std::ranges::range_value_t<R>, Value>;

template <range_over<std::string> Range>
void print(Range&& range)
{
    for (const std::string& val : range)
    {
        std::cout << val << std::endl;
    }
}
(more…)