So i am basically almost done with my C++ App Logic Wise tho the only thing i struggle with and wanna figure it is how to include a seperate class into my main class constructors >.>

Mostly due to the fact that currently in my Code my main Code has 2 Objects tho ErrorWin Object is right now the only one that exist twice as seperate Objects which itd like to fix >.>

So this is my first Object in my Main Function which just calls my DisplayWindow Function while my ErrorWin Object calls the Display Error Window Function :P

int main() {
  ErrorWindow ErrorWin;
  MainWindow MainWin;

  if (ProgramPath.empty()) {
    ErrorWin.DisplayErrorWindow();
    return Fl::run();
  }

  MainWin.DisplayMainWindow();
  return Fl::run();
}

Now the Main Issue is that only my First Text basically gets displayed in the Error Window even tho my switch Statement is set to display a different error text basically according to my callback but that obviously does not work due to theyre being seperate ErrorWin Objects :(

void MainWindow::CallbackSaveFile(Fl_Widget* Widget, void* Data) {
  MainWindow* MainWindowData = static_cast<MainWindow*>(Data);
  ErrorWindow ErrorWin;

  if (!MainWindowData->InputFile.empty()) {
    ...
  } else {
    ErrorWin.DisplayErrorWindow();
  }
}

On Saturday, the ISO C++ committee completed technical work on C++26 in (partly) sunny London Croydon, UK. We resolved the remaining international comments on the C++26 draft, and are now producing the final document to be sent out for its international approval ballot (Draft International Standard, or DIS) and final editorial work, to be published in the near future by ISO.

The 6.11 release for Qt Framework is now available, with improved performance, newly supported techniques and capabilities on graphics, connectivity and languages, not to mention a whole new approach to asynchronous C++ coding.

• Hardware-Accelerated 2D Rendering: A new module, Qt Canvas Painter, based on the HTML Canvas 2D Context, provides performance & productivity gains.
• 3D Improvements: New rendering techniques Screen Space Global Illumination (SSGI) as an option for lightmap baking, and Screen Space Reflections (SSR). Also imrovements on the Temporal Anti-aliasing algorithm with motion vectors. New user-defined render passes for post-processing effects, color picking, layer masks, etc. directly in QML.
• Interactive Graphs: You can now implement custom graphs where a user-defined delegate renders each data point. There's a new Qt example, the Wind Turbine Dashboard, and many improvements, e.g. new ways to style line graphs, and multi-axis support on 3D graphs.
• Declarative Approach to C++: Qt Task Tree brings a whole new approach to asynchronous coding and C++ API design in Qt. In addition, various APIs have been unified to allow adapting any asynchronous task to work with the new module.
• Other Improvements: Improvements on vector graphics, controls, and accessibility. Connecting to web servicers is now easier with the new module, Qt OpenAPI. Navigating in an IDE between QML and C++, and making data available from C++ backend code to Qt Quick have gotten easier. A wealth of other improvements, such as for multimedia, Android, and API documentation.

Any std::valarray users represent?

PVS-Studio presents a series of webinars on how to build your own programming language in C++. In the first session, we will go over what’s inside the “black box”. In clear and plain terms, they’ll explain what a lexer, parser, a semantic analyzer, and an evaluator are.

Yuri Minaev, C++ architect at PVS-Studio, will talk about what these components are, why they’re needed, and how they work. Welcome to join.

Major new features:

• The ISO C23 free_sized, free_aligned_sized, memset_explicit, and memalignment functions have been added.

• As specified in ISO C23, the assert macro is defined to take variable arguments to support expressions with a comma inside a compound literal initializer not surrounded by parentheses.

• For ISO C23, the functions bsearch, memchr, strchr, strpbrk, strrchr, strstr, wcschr, wcspbrk, wcsrchr, wcsstr and wmemchr that return pointers into their input arrays now have definitions as macros that return a pointer to a const-qualified type when the input argument is a pointer to a const-qualified type.

• The ISO C23 typedef names long_double_t, _Float32_t, _Float64_t, and (on platforms supporting _Float128) _Float128_t, introduced in TS 18661-3:2015, have been added to <math.h>.

• The ISO C23 optional time bases TIME_MONOTONIC, TIME_ACTIVE, and TIME_THREAD_ACTIVE have been added.

• On Linux, the mseal function has been added. It allows for sealing memory mappings to prevent further changes during process execution, such as changes to protection permissions, unmapping, relocation to another location, or shrinking the size.

• Additional optimized and correctly rounded mathematical functions have been imported from the CORE-MATH project, in particular acosh, asinh, atanh, erf, erfc, lgamma, and tgamma.

• Optimized implementations for fma, fmaf, remainder, remaindef, frexpf, frexp, frexpl (binary128), and frexpl (intel96) have been added.

• The SVID handling for acosf, acoshf, asinhf, atan2f, atanhf, coshf, fmodf, lgammaf/lgammaf_r, log10f, remainderf, sinhf, sqrtf, tgammaf, y0/j0, y1/j1, and yn/jn was moved to compat symbols, allowing improvements in performance.

• Experimental support for building with clang has been added. It requires at least clang version 18, aarch64-linux-gnu or x86_64-linux-gnu targets, and a libgcc compatible runtime (including libgcc_s.so for pthread cancellation and backtrace runtime support).

• On Linux, the openat2 function has been added. It is an extension of openat and provides a superset of its functionality. It is supported only in LFS mode and is a cancellable entrypoint.

• On AArch64, support for 2MB transparent huge pages has been enabled by default in malloc (similar to setting glibc.malloc.hugetlb=1 tunable).

• On AArch64 Linux targets supporting the Scalable Matrix Extension (SME), the clone() system call wrapper will disable the ZA state of the SME.

• On AArch64 targets supporting the Branch Target Identification (BTI) extension, it is possible to enforce that all binaries in the process support BTI using the glibc.cpu.aarch64_bti tunable.

• On AArch64 Linux targets supporting at least one of the branch protection extensions (e.g. Branch Target Identification or Guarded Control Stack), it is possible to use LD_DEBUG=security to make the dynamic linker show warning messages about loaded binaries that do not support the corresponding security feature.

• On AArch64, vector variants of the new C23 exp2m1, exp10m1, log10p1, log2p1, and rsqrt routines have been added.

• On RISC-V, an RVV-optimized implementation of memset has been added.

• On x86, support for the Intel Nova Lake and Wildcat Lake processors has been added.

• The test suite has seen significant improvements in particular around the scanf, strerror, strsignal functions and multithreaded testing.

• Unicode support has been updated to Unicode 17.0.0.

• The manual has been updated and modernized, in particular also regarding many of its code examples.

geteilt von: https://programming.dev/post/42846946

Hi everyone,

we, the iceoryx community, just released iceoryx2 v0.8, an ultra-low latency inter-process communication middleware in Rust, with C, C++, Python and with this release, C# bindings.

If you are into robotics, embedded real-time systems (especially safety-critical), autonomous vehicles or just want to hack around, iceoryx2 is built with you in mind.

Check out our release announcement for more details: https://ekxide.io/blog/iceoryx2-0.8-release

And the link to the project: https://github.com/eclipse-iceoryx/iceoryx2