-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
xz project dependant libraries
What will happen now with xz project dependant libraries due the recent drama?
At the moment some boost libraries are unusable (at least via vcpkg), is there any way to still use them, or wait until it will be resolved?
https://redd.it/1buqsbw
@r_cpp
C++ after AI
I 'm 17 and a CS student
I have a lot of time to learn anything ...
In recent years technologies like robots etc is on peak.. I researched alot about which programming language will be in demand after AI .. but i didn't find any cuz AI can write all of them ..so i decided why not i learn to develop AI.
....
So I decided to learn these..
PYTHON ...
Python is a language that can create an AI and also control hardware in robotic development..and it is easy to learn.
C++...
C++ is faster as compared to Python..It is a bit difficult language but after AI i think it will be alot easier to learn..
but i don't know that it is in demand or not?
Is it okay to learn python as an AI language and C++ as an hardware control language to get a job in robotic development(as a robot need an AI and hardware control programming)?
https://redd.it/1buh5kp
@r_cpp
Best library for gui (windows)
Hi all! I started practicing reverse engineering for Windows programs and want to get better at protecting and understanding the bottlenecks of Windows applications. In my opinion QT is very redundant for my task.
The only option is Win32, but it seemed to me that it was very huge in terms of the number of lines of code written.
I would like to know your opinion, thank you.
https://redd.it/1bu8fsm
@r_cpp
One flew over the Mixin nest
The mix-in pattern aims to solve the same problem that dynamic polymorphism tries to solve but without virtual functions. The basic idea is to have a bunch of orthogonal objects that have relevant functionalities by themselves -- sometimes not. Sometimes they are designed exclusively to extend other object's functionalities -- and then being able to combine them to extend their individual functionalities.
An example is this:
// DataItem is completely oblivious to what we have in store for it
//
template<typename T>
struct DataItem {
using value_type = T;
void set(const value_type &value) { value_ = value; }
const value_type &get() const { return (value_); }
private:
value_type value_ { };
};
// Generic undo mechanism
//
template<typename B>
struct Undo : public B {
using value_type = typename B::value_type;
void set(const value_type &value) {
before_ = B::get();
B::set(value);
}
void undo() { B::set(before_); }
private:
value_type before_ { };
};
// Generic redo mechanism
//
template<typename B>
struct Redo : public B {
using value_type = typename B::value_type;
void set(const value_type &value) {
after_ = value;
B::set(value);
}
void redo() { B::set(after_); }
private:
value_type after_ { };
};
// Cuckoo happens here
//
using SpecialInt = Redo<Undo<DataItem<int>>>;
// -----------------------------------------------------------------------------
int main(int, char *[]) {
SpecialInt my_int;
my_int.set(100);
std::cout << "Initial Value: " << my_int.get() << std::endl;
my_int.set(200);
std::cout << "Second Value: " << my_int.get() << std::endl;
my_int.undo();
std::cout << "After Undo: " << my_int.get() << std::endl;
my_int.redo();
std::cout << "After Redo: " << my_int.get() << std::endl;
return (0);
}
C++ modules: build times and ease of use
There are two primary benefits to C++20's modules:
Ease of use, afforded by the fact we don't need to separate interface and implementation.
Better build throughput, because modules are build once and imported everywhere.
There are more benefits to modules, such as encapsulation, but the above are the big selling points. However, with current implementations it looks like those points are also contradictory.
In my experience, any change to the module interface unit causes recompilation of all files that import the module. The problem is further exacerbated if you architect your code as a fewer larger modules (via module partitions), which also seems to be the recommended way to go.
This leads to terrible incremental build times. The only way around is to use module implementation units and split interface from implementation. But then you are not really better off than using header/cpp files again (and you will need to deal with all the current modules-related headaches in implementations with almost none of the benefits).
Currently, I expect it will be nice to consume third party code as modules (especially import std; once it works reliably), but the incremental build times alone for code that we actively work on look like a not-starter for any non-trivial code base.
So what's the incentive to modularize your code right now? Am I just plain wrong in my assessment?
https://redd.it/1btx5j6
@r_cpp
Boost/C++ mailing freaked me out
https://lists.boost.org/Archives/boost/2024/04/256403.php
https://redd.it/1btveuj
@r_cpp
Undefined Reference Errors in Windows Filtering Platform (WFP) Code
Hello Reddit community! I'm working on a project that involves using the Windows Filtering Platform (WFP) to block specific IP addresses. I've written a C++ program that attempts to add a filter to block an IP range, but I'm encountering some linker errors related to FWPM_CONDITION_IP_REMOTE_ADDRESS and FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4.
Here's the error message I'm seeing
`undefined reference to `FWPM_CONDITION_IP_REMOTE_ADDRESS'`
`undefined reference to `FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4'`
The code is below:
'#include<iostream>
#include<string>
#include<ws2tcpip.h>
#include<windows.h>
#include<fwpmu.h>
#pragma comment(lib, "Fwpuclnt.lib")
using namespace std;
// Function to convert std::string to std::wstring
void blockIP(const string& ip)
{
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
HANDLE engineHandle = NULL;
DWORD res = FwpmEngineOpen0(NULL, RPC_C_AUTHN_WINNT, NULL, NULL, &engineHandle);
if (res != ERROR_SUCCESS)
{
cout << "Failed To Open WFP Engine: " << res << endl;
return;
}
FWPM_FILTER0 filter = { 0 };
filter.displayData.name = const_cast<wchar_t*>(L"Block IP Range Filter");
filter.layerKey = FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4;
filter.action.type = FWP_ACTION_BLOCK;
filter.weight.type = FWP_UINT64;
UINT64* weightValue = new UINT64;
*weightValue = 0x7FFFFFFF;
filter.weight.uint64 = weightValue;
FWPM_FILTER_CONDITION0 condition = { 0 };
condition.fieldKey = FWPM_CONDITION_IP_REMOTE_ADDRESS;
condition.matchType = FWP_MATCH_RANGE;
condition.conditionValue.type = FWP_V4_ADDR_MASK;
condition.conditionValue.v4AddrMask = new FWP_V4_ADDR_AND_MASK;
InetPton(AF_INET, ip.c_str(), &condition.conditionValue.v4AddrMask->addr);
condition.conditionValue.v4AddrMask->mask = 0xFFFFFFFF;
filter.numFilterConditions = 1;
filter.filterCondition = &condition;
UINT64 filterID = 0;
res = FwpmFilterAdd0(engineHandle, &filter, NULL, &filterID);
if (res != ERROR_SUCCESS) cout << "Failed To Add Filter: " << res << endl;
else cout << "Filter Added Successfully" << endl << "FilterID: " << filterID << endl;
FwpmEngineClose0(engineHandle);
CoUninitialize();
}
int main()
{
string ip = "192.168.1.0";
blockIP(ip);
return 0;
}`
https://redd.it/1btr9nc
@r_cpp
Real-time Confessions in C++ - Fabian Renn-Giles - https://youtu.be/JG7lqt7V1uY
Leveraging Pruning & Quantization for Real-Time Audio Applications - Dharanipathi Rathna Kumar - [https://youtu.be/DR6zPlmpa8I](https://youtu.be/DR6zPlmpa8I)
Workshop: An Introduction to Inclusive Design of Audio Products - Accessibility Panel - https://youtu.be/sB900naLHHo
03/18/2024 - 03/24/2024
RADSan: A Realtime-Safety Sanitizer - David Trevelyan & Ali Barker - [https://youtu.be/P8rDWmmMmlg](https://youtu.be/P8rDWmmMmlg)
Generative Audio: Indian Art, Computer Music - George Panicker - https://youtu.be/ppc66A3pdow
KEYNOTE: NIME to NISE: Rethinking the Design & Evaluation of Musical Interfaces - Anna Xambó Sedó - [https://youtu.be/q5Mq8x\_8if0](https://youtu.be/q5Mq8x_8if0)
03/11/2024 - 03/17/2024
Building AI Music Tools: An Engineer’s Guide to Prototyping - Jamie Pond - https://youtu.be/1lEWl-MTA6k
GeoShred: Modeling South Asian and Chinese Instruments - Gregory Pat Scandalis - [https://youtu.be/n-AjbS1cyvQ](https://youtu.be/n-AjbS1cyvQ)
WebAudio IDE: Using Web Technologies to Rapidly Assemble Cross-Platform Audio Pipelines - Synervoz - https://youtu.be/zrfF1OtD-Cc
03/04/2024 - 03/10/2024
Practical DSP & Audio Programming Workshop and Tutorial - Dynamic Cast - [https://youtu.be/UNsZ1TzyMEk](https://youtu.be/UNsZ1TzyMEk)
Meeting C++
03/04/2024 - 03/10/2024
Starting my modern C++ Project with CMake in 2024 - Jens Weller - https://www.youtube.com/watch?v=3KlLGNo5bn0
https://redd.it/1bt625a
@r_cpp
Random distributions are not one-size-fits-all (part 2)
https://codingnest.com/random-distributions-are-not-one-size-fits-all-part-2/
https://redd.it/1bt52zp
@r_cpp
How to define binary data structures across compilers and architectures?
I’ve mostly been working in the embedded world in the past years but also have a lot of experience with python and C in the OS environment. There have been times where I logged some data to the PC from an embedded device over UART so either a binary data structure wasn’t needed or easy to implement with explicitly defined array offsets.
Im know starting a project with reasonably fast data rates from a Zynq over the gigabit Ethernet. I want to send arbitrary messages over the link to be process by either a C++ or Python based application on a PC.
Does anyone know of an elegant way / tool to define binary data structures across languages, compilers and architectures? Sure we could us C structs but there are issues on implementation there. This could be solved through attributes etc. tho.
https://redd.it/1bt1ngz
@r_cpp
Linked List
Hello guys, I am trying to implement Linked List using C++. I need help on a part.
LinkedList.h
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include "Node.h"
namespace LinkedList
{
template <class T>
class LinkedList
{
public:
LinkedList() : m_head(nullptr), m_len(0){};
LinkedList(T p_value) : m_head(std::make_shared<Node<T>>(p_value)), m_len(1){};
size_t Length() { return m_len; };
virtual void PushFront(T p_value) = 0;
protected:
std::shared_ptr<Node<T>> m_head;
size_t m_len;
};
}
#endif
Single.h
#ifndef SINGLYLIST_H
#define SINGLYLIST_H
#include "LinkedList.h"
namespace LinkedList
{
template <class T>
class SinglyLinkedList : public LinkedList<T>
{
public:
using LinkedList<T>::LinkedList;
void PushFront(T p_value);
};
}
#endif
Single.cpp
#include "Single.h"
#include <iostream>
template <class T>
void LinkedList::SinglyLinkedList<T>::PushFront(T p_value)
{
std::cout << p_value << std::endl;
}
When I run this code in main.cpp
#include "Single.h"
int main(void)
{
LinkedList::SinglyLinkedList<int> list = {10};
list.PushFront(20);
return 0;
}
I get this error:
Undefined symbols for architecture arm64:
"LinkedList::SinglyLinkedList<int>::PushFront(int)", referenced from:
_main in main.cpp.o
vtable for LinkedList::SinglyLinkedList<int> in main.cpp.o
ld: symbol(s) not found for architecture arm64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [linkedlist] Error 1
make[1]: *** [CMakeFiles/linkedlist.dir/all] Error 2
make: *** [all] Error 2
https://redd.it/1bt0xxa
@r_cpp
Try real dark theme on Compiler Explorer ;) (More -> Settings -> Site theme -> Real Dark)
https://redd.it/1bsyeuw
@r_cpp
Polymorphic Memory Resources - Worth Using?
https://open.substack.com/pub/lucisqr/p/polymorphic-memory-resources-worth?r=1ecjkz&utm_campaign=post&utm_medium=web&showWelcomeOnShare=true
https://redd.it/1bssm75
@r_cpp
Why left-shift 64bits is limited to 63bits?
I'm creating a toy programming language, and I'm implementing the left-shift operator. The integers in this language are 64bits.
As I'm implementing this, it makes sense to me that left-shifting by 0 performs no shifting. Conversely, it also makes sense to me that left-shifting by 64 would introduce 64 zeros on the right, and thus turn the integer into 0. Yet, the max shift value for a 64bit int is 63; otherwise, the operation is undefined.
What is the possible rationale to limit shifting to less than bit-size, as opposed to equal bit-size?
In other words, I expected a type of symmetry:
>0 shift: no change
>
>max shift: turn to 0
​
https://redd.it/1bsr7jj
@r_cpp
How Microsoft delivers Office using C++
https://www.youtube.com/watch?v=0QtX-nMlz0Q
https://redd.it/1bskzr2
@r_cpp
“Generic” C++ jobs?
I’ve been told time and time again that computer graphics is a field that can be really difficult to break into without years of prior work experience, especially low-level computing experience. I’m building out my knowledge and portfolio in the field but am unsure of what will happen to me after graduation from university. I know that asking for a “C++ job” or any programming language specific developer job doesn’t make sense, since languages are just tools and different domain applications of them have very different skillset requirements. But I also know that I really want to be exposed to C++ in a professional environment, and for that I’ve been told to seek “general” or “generic” low level dev jobs with zero clue what that means. What kinds of roles would take a fresh grad on for something low level, ideally in C++ but in any language really, with a portfolio that isn’t targeting its domain specifically?
https://redd.it/1bup0rf
@r_cpp
Qt 6.7 released
https://www.qt.io/blog/qt-6.7-released
https://redd.it/1buffap
@r_cpp
Move semantics with composition
Hello,
I fear this is a pretty common scenario, but I was not able to find any post about this.
I am writing an application in which I have the following composition of objects:
* an object storing some data
* several services using the above data, as well as other private resources
* an outer object defining the scope and lifetime of the storage and of the services
Here are simplified definitions:
// Wraps a single integer
struct storage {
void set(int i) { m_counter = i; }
int get() const { return m_counter; }
private:
int m_counter;
};
// Needs access to storage and keeps a reference to it.
struct member_service {
member_service(storage& s)
: m_ref_storage(s) {}
void run_service(int i) {
m_ref_storage.set(i);
}
int get() const { return m_ref_storage.get(); }
private:
storage& m_ref_storage;
};
// Here is the outer wrapper
struct wrapper {
wrapper()
: m_storage()
, m_member(m_storage) {}
void init_storage(int i) { m_storage.set(i); }
void run_service(int i) { m_member.run_service(i); }
void print() {
std::cout << "storage contains " << m_storage.get()
<< ", member sees " << m_member.get()
<< std::endl;
}
private:
storage m_storage;
member_service m_member;
};
And here is the code that shows the issue:
wrapper first;
first.run_service(1); // sets storage through the service
first.print();
// outputs: storage contains 1, member sees 1
wrapper second { std::move(first) };
second.run_service(2); // sets storage through the service
second.print();
// outputs: storage contains 1, member sees 2
first.print();
// outputs: storage contains 2, member sees 2
When the wrapper object is **moved** (and I need it to be *movable*), the reference `m_member.m_ref_storage` is obviously not updated. This means the service inside the moved-to object still *points* to the storage of the moved-from object.
Any idea on how to address this?
If I explicitly define a move-constructor for the `wrapper` class, I then need to expose a way to modify the reference stored in the `member_service` class. Wouldn't this mean that I leak implementation details to the outer object?
The real scenario is more complex, but I know that storing the `wrapper` objects on the HEAP could remove the need for them to be copiable/movable, and remove this issue alltogether. I would like to avoid this though, if possible.
https://redd.it/1bu8l0x
@r_cpp
Soup Build is finally ready for Beta!
Release Soup 0.38.0 (Beta) · SoupBuild/Soup
All core functionality is implemented and the build system is ready to try out. Both Linux (Ubuntu) and Windows have been tested to be working. I am looking for folks to test things out, provide feedback and help iron out issues!
https://redd.it/1bu0g7d
@r_cpp
Technical Note. From C++98 to C++2x
This technical note is devoted to covering information regarding all primary C++ programming language standards: C++03/98/11/14/17/20/23.
I am glad to share an update about a technical note with some details regarding the C and all primary C++ programming language standards.
As of *April 02, 2024*, this technical note in PDF format consists of 118 pages.
* GitHub Repository: [https://github.com/burlachenkok/CPP_from_1998_to_2020](https://github.com/burlachenkok/CPP_from_1998_to_2020)
* Link to Markdown: [Cpp-Technical-Note.md](https://github.com/burlachenkok/CPP_from_1998_to_2020/blob/main/Cpp-Technical-Note.md)
The C++ programming language is complex, but currently, it's the fastest high-level general-purpose programming language in the world.
The information from this technical note can be helpful mainly for three categories of people:
* People who want to refresh or go deep into several language constructions in C++.
* Obtain a pretty in-depth overview of new features from C++11/14/17/20/23.
* People who need to support (legacy) C++03 or C99 code base.
https://redd.it/1btxx67
@r_cpp
C++ Jobs - Q2 2024
Rules For Individuals
---------------------
* **Don't** create top-level comments - those are for employers.
* Feel free to reply to top-level comments with **on-topic** questions.
* I will create top-level comments for **meta** discussion and **individuals looking for work**.
Rules For Employers
-------------------
* If you're hiring **directly**, you're fine, skip this bullet point. If you're a **third-party recruiter**, see the extra rules below.
* **One** top-level comment per employer. If you have multiple job openings, that's great, but please consolidate their descriptions or mention them in replies to your own top-level comment.
* **Don't** use URL shorteners. [reddiquette][] forbids them because they're opaque to the spam filter.
* Templates are awesome. Please **use** the following template. As the "formatting help" says, use \*\*two stars\*\* to **bold text**. Use empty lines to separate sections.
* **Proofread** your comment after posting it, and edit any formatting mistakes.
---
\*\*Company:\*\* [Company name; also, use the "formatting help" to make it a link to your company's website, or a specific careers page if you have one.]
\*\*Type:\*\* [Full time, part time, internship, contract, etc.]
\*\*Compensation:\*\* [This section is **optional**, and you can omit it without explaining why. However, including it will help your job posting stand out as there is [extreme demand][] from candidates looking for this info. If you choose to provide this section, it must contain (a range of) **actual numbers** - don't waste anyone's time by saying "Compensation: Competitive."]
\*\*Location:\*\* [Where's your office - or if you're hiring at multiple offices, list them. If your workplace language isn't English, please specify it.]
\*\*Remote:\*\* [Do you offer the option of working remotely? If so, do you require employees to live in certain areas or time zones?]
\*\*Visa Sponsorship:\*\* [Does your company sponsor visas?]
\*\*Description:\*\* [What does your company do, and what are you hiring C++ devs for? How much experience are you looking for, and what seniority levels are you hiring for? The more details you provide, the better.]
\*\*Technologies:\*\* [Required: what version of the C++ Standard do you mainly use? Optional: do you use Linux/Mac/Windows, are there languages you use in addition to C++, are there technologies like OpenGL or libraries like Boost that you need/want/like experience with, etc.]
\*\*Contact:\*\* [How do you want to be contacted? Email, reddit PM, telepathy, gravitational waves?]
---
Extra Rules For Third-Party Recruiters
--------------------------------------
Send modmail to request pre-approval on a case-by-case basis. We'll want to hear what info you can provide (in this case you can withhold client company names, and compensation info is still recommended but optional). We hope that you can connect candidates with jobs that would otherwise be unavailable, and we expect you to treat candidates well.
Previous Post
-------------
* [C++ Jobs - Q1 2024](https://www.reddit.com/r/cpp/comments/18w2e6a/c_jobs_q1_2024/)
[reddiquette]: https://support.reddithelp.com/hc/en-us/articles/205926439
[extreme demand]: https://www.reddit.com/r/cpp/comments/sz0cd5/c_jobs_threads_should_include_salarycompensation/
https://redd.it/1btvc6m
@r_cpp
What is going on with <limits>?
Why std::numeric_limits<float>::min() returns a positive value? Couldn't they call it std::numeric_limits<T>::smallest_positive()?
And why did they speciailize std::numeric_limits<T>::infinity() for integers? Why did they chose the value 0 for <int>::infinity()? Is it not possible to put a static_assert and make it a compile time error?
Jesus Christ...
https://redd.it/1bt9v4o
@r_cpp
C++ Videos Released Last Month - March 2024 (Updated to Include Videos Released 03/25/2024 - 03/31/2024)
This month the following C++ videos have been published to YouTube. A new post will be made each week as more videos are released
CppCon
03/25/2024 - 03/31/2024
Plenary: Coping With Other People's C++ Code - Laura Savino - [https://youtu.be/qyz6sOVON68](https://youtu.be/qyz6sOVON68)
Behavioral Modeling in HW/SW Co-design Using C++ Coroutines - Jeffrey Erickson & Sebastian Schoenberg - https://youtu.be/KmLunUoBcQk
Writing Python Bindings for C++ Libraries: Easy-to-use Performance - Saksham Sharma - [https://youtu.be/rB7c69Z5Kus](https://youtu.be/rB7c69Z5Kus)
Building Effective Embedded Systems in C++: Architectural Best Practices - Gili Kamma - https://youtu.be/xv7jf2jQezI
Abstraction Patterns for Cross Platform Development Using C++ - Al-Afiq Yeong - [https://youtu.be/Et0ofYRi3fw](https://youtu.be/Et0ofYRi3fw)
03/18/2024 - 03/24/2024
Getting Started with C++ - Michael Price - https://youtu.be/NReDubvNjRg
Better Code: Exploring Validity in C++ - David Sankel - [https://youtu.be/wxzQXj6WW2E](https://youtu.be/wxzQXj6WW2E)
Better Code: Contracts in C++ - Sean Parent & Dave Abrahams - https://youtu.be/OWsepDEh5lQ
Back to Basics: Forwarding References - How to Forward Parameters in Modern C++ - Mateusz Pusz - [https://youtu.be/0GXnfi9RAlU](https://youtu.be/0GXnfi9RAlU)
Tips on Surveying the C++ Community - Anastasia Kazakova - https://youtu.be/54LiB\_OxPHE
03/11/2024 - 03/17/2024
C++ Memory Model: from C++11 to C++23 - Alex Dathskovsky - [https://youtu.be/SVEYNEWZLo4](https://youtu.be/SVEYNEWZLo4)
Building Consensus on a Set of Rules for Our Massive C++ Codebase - Sherry Sontag - https://youtu.be/-Bth3PFsrsw
Designing Fast and Efficient List-like Data Structures - Yannic Bonenberger - [https://youtu.be/stfEry0zz5E](https://youtu.be/stfEry0zz5E)
Iteration Revisited: A Safer Iteration Model for Cpp - Tristan Brindle - https://youtu.be/nDyjCMnTu7o
C++ in the Developing World: Why it Matters - Mathew Benson - [https://youtu.be/dHxzADxQv48](https://youtu.be/dHxzADxQv48)
03/04/2024 - 03/10/2024
An Introduction to Tracy Profiler in C++ - Marcos Slomp - https://youtu.be/ghXk3Bk5F2U
Safety and Security for C++: Panel Discussion - Hosted by Michael Wong - [https://youtu.be/R10pXWHpPn4](https://youtu.be/R10pXWHpPn4)
Optimizing Away C++ Virtual Functions May Be Pointless - Shachar Shemesh - https://youtu.be/i5MAXAxp\_Tw
Building Bridges: Leveraging C++ and ROS for Simulators, Sensor Data and Algorithms - [https://youtu.be/w6-FCWJrZko](https://youtu.be/w6-FCWJrZko)
Khronos APIs for Heterogeneous Compute and Safety: SYCL and SYCL SC - Michael Wong, Nevin Liber & Verena Beckham - https://youtu.be/JHiBeuRqVkY
02/26/2024 - 03/03/2024
Leveraging the Power of C++ for Efficient Machine Learning on Embedded Devices - Adrian Stanciu - [https://youtu.be/5j05RWh1ypk](https://youtu.be/5j05RWh1ypk)
C++ Regular, Revisited - Victor Ciura - https://youtu.be/PFI\_rpboj8U
Evolution of a Median Algorithm in C++ - Pete Isensee - [https://youtu.be/izxuLq\_HZHA](https://youtu.be/izxuLq_HZHA)
Back to Basics: The Rule of Five in C++ - Andre Kostur - https://youtu.be/juAZDfsaMvY
C++23: An Overview of Almost All New and Updated Features - Marc Gregoire - [https://youtu.be/Cttb8vMuq-Y](https://youtu.be/Cttb8vMuq-Y)
All of these talks can also be accessed at [https://cppcon.programmingarchive.com](https://cppcon.programmingarchive.com) where you can also find information on how to get early access to the rest of the CppCon 2023 videos and lightning talks.
Audio Developer Conference
03/25/2024 - 03/31/2024
Leveraging the Power of Transparent Comparators in C++
https://johnfarrier.com/transparent-comparators-in-c23/
https://redd.it/1bt1wlk
@r_cpp
Mathematical special functions in libc++
Since C++17 the standard contains special math functions (e.g. associated Laguerre polynomials).
To this day they are not supported with libc++.
See this godbolt which succeeds for libstdc++ but fails with libc++.
One should also note that this is even the last C++17 library feature missing any implementation for Clang libc++.
I found the following discussions regarding this issue
- https://reviews.llvm.org/D58876:
Implementing std::assoc_laguerre, std::assoc_legendre, std::hermite, std::laguerre, and std::legendre, but without a review since March 2019.
- https://reviews.llvm.org/D59937:
Implementing std::expint, but without a review since March 2019.
- https://reviews.llvm.org/D142806:
Pulling in all of Boost.Math to implement the special math functions.
- docs.google.com (see section "Agenda for 31-10-2023")
Discussion about current status and possibility of adding dependency on Boost.Math.
- https://github.com/llvm/llvm-project/issues/72055: Recent github discussion linking all previous pages.
In multiple comments it is mentioned that the libc++ community does not have the resources to review the above linked merge requests.
Thus, custom implementations are probably not going to make it into trunk (and would be a waste of time)?
Would it be of help if I review the merge requests?
Does libc++ accept reviews from externals (me not being part of a review board)?
Do you have other ideas of how I could be of help here?
Do you know where and to whom I should talk to?
As a note aside:
I have an extensive mathematical background and have rolled out custom implementations for some of these functions.
https://redd.it/1bt1lne
@r_cpp
Is VS Code good for C++
I’m learning C++ and I wonder if VS Code is a good editor for C++
https://redd.it/1bsy9k8
@r_cpp
C++ Show and Tell - April 2024
Use this thread to share anything you've written in C++. This includes:
* a tool you've written
* a game you've been working on
* your first non-trivial C++ program
The rules of this thread are very straight forward:
* The project must involve C++ in some way.
* It must be something you (alone or with others) have done.
* Please share a link, if applicable.
* Please post images, if applicable.
If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.
Last month's thread: https://www.reddit.com/r/cpp/comments/1b3pj0g/c_show_and_tell_march_2024/
https://redd.it/1bsxuxt
@r_cpp
What type of people go to and what type of person gets the most out of going to CppCon?
https://redd.it/1bsr2vy
@r_cpp
Simple Type Safe Memory Pool
https://alexwritesablog.com/posts/a-simple-object-pool/
https://redd.it/1bskls6
@r_cpp
Do you tend to install your development dependencies globally?
I've always generally tried to avoid it. I like to use CMake's externalProject_Add or fetchContent to install a project's dependencies into a local directory. In the past I've used Docker or Vagrant to set up development environments.
But now I'm looking into Conan, and when I try to fetch GLEW it wants to use apt to install a whole bunch of -dev packages globally. I feel uneasy about this, but can't really justify it. I'm not sure what it does on other platforms, like Windows, which doesn't have a system installer; I've only tried it on Linux so far.
https://redd.it/1bsifvk
@r_cpp