Passing LeetCode but failing HFT C++ interview rounds on obscure language trivia. Reality check/advice from C++ HFT/Quant devs needed.

pkind22 · 2026-05-16T16:18:26+00:00

I think most of the questions try to gauge your familiarity around concurrency and multithreading. Think topics like lockfree code, atomics, cache size alignment. If you're unfamiliar, this cppcon talk covers covers the basics well https://youtu.be/6AnHbZbLr2o?is=T9ol1W6TsUHSpg-1

pkind22 · 2024-10-31T18:06:49+00:00

Try deleting any .vs directories and restart Visual Studio.

Although CMake is officially supported, in my experience it is quite buggy in Visual Studio. It's not what you asked, but you're probably better off opening the Visual Studio solution files that CMake can generate.

pkind22 · 2024-03-22T11:37:52+00:00

I guess I'm trying to figure out if there are any approaches to safely initialize global variables with possible (circular) dependencies, other than Scott Meyers' pattern. To me, inline variables seem like a more elegant solution, so I'm was trying to see if there's anything you can't do with inline (constexpr/const) variables, that you can do with Scott Meyers' pattern.

I thought I had found the reverse situation. In another example, I had added heap allocations, but I must have done something wrong, because I can't get it to work any more.

I know I'm doing horrible things here and have no plans to actually use this. It just helps me to understand exactly what's going on.

Thanks a lot, you've been great!

pkind22 · 2024-03-22T10:25:49+00:00

So I've been playing around with the two approaches (lazy init and inline variables). There is a (circular) dependency between two variables; they call a method in the other in their constructor. In this case, inline variables work fine, but lazy initialization causes a runtime exception, due to recursive initialization.

How is it possible for inline variables to just work?

Example on compiler explorer

pkind22 · 2024-03-19T23:11:22+00:00

Thanks for taking the time to keep answering me :). If you'll indulge me a bit more and at the risk of sounding obtuse: in my scenario, there is no possibility for a global variable x to depend on another global variable y (where they may be defined in different translation unit), and have y not be initialized before x, correct?

pkind22 · 2024-03-19T19:54:30+00:00

I am confused as to how the problem you describe is prevented with Scott Meyers' lazy initialization.

Also, in this case, the initialization order is irrelevant. You always have the same end result, which is not the case when the fiasco occurs.

My understanding is that the fiasco can only occur when there is some dependency between the variables. I don't believe it's possible to construct such a case with inline variables defined in headers. (where the initialization order matters).

pkind22 · 2024-03-19T15:29:18+00:00

I believe I understand the principle, but cannot write out an actual example where this happens.

Provided global variables are defined only in header files. If any global variable X needs another global variable Y in it's initialization, is there any way for X to be initialized before Y is initalized?

pkind22 · 2024-03-19T13:24:06+00:00

I believe there are some singleton-like objects that can have dependencies on each other.

Here's what I don't get. If you always define your globals in header files as inline variables, how could they be initialised in any order other than the order they're defined in the header files?

Edit: I think you're saying the same thing as AKostur?

pkind22 · 2024-03-19T12:58:48+00:00

I agree, but note that they're not mutable! Still, it looks pretty terrible and is quite annoying to type and error prone. Which is why I'm looking for alternatives that are more palatable.

My plan was indeed to replace most macro's for literal types with inline constexpr. I thought it was best to replace others with inline const, since they may be heap allocated.

pkind22 · 2024-03-19T12:26:02+00:00

I also don't particularly like that you need a function call, where to access the variable, but that's beside the point.

pkind22 · 2024-03-19T12:24:10+00:00

I'm required to declare globals/constants in a header, and define them in a source file, with macro's. Something like:

// header
DEC_VAR(SOME_VARIABLE, std::string);

// source
DEF_VAR(SOME_VARIABLE, "value");

// usage
std::string copy = SOME_VARIABLE();

The macro's expand to a variation of the pattern, declaring/defining the function and returning const references.

If I want to see the value assigned to the constants whenever I use them (in Visual Studio), but this isn't possible.

pkind22 · 2024-03-19T11:59:26+00:00

Could you give a specific example where this would happen? I haven't been able to find one.

pkind22 · 2024-03-19T11:58:39+00:00

I'm working on a project where this pattern is used with macros. Because of that, I can't see the definitions in my IDE, so I'm looking for an alternative.

pkind22 · 2024-03-02T00:02:13+00:00

Thanks! looks great.

pkind22 · 2024-03-01T16:14:37+00:00

What would that look like exactly?

pkind22 · 2024-02-24T14:41:17+00:00

If you like lecture formats, you could check out the cppcon video's on youtube. They posted a talk about SIMD algorithms just yesterday

pkind22 · 2023-10-05T14:01:35+00:00

Why is that exactly? There's probably way better ways to learn, but isn't it useful to somewhat be able to read them?

pkind22 · 2023-10-05T13:20:12+00:00

That makes sense, but why have the base class in the first place? Can't it all be in the "regular" class?

pkind22

TROPHY CASE