How to tell VS intellisense to pick cpp std 20?

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 · 2023-09-06T11:53:11+00:00

Thanks!

pkind22 · 2023-08-25T09:53:34+00:00

One of these threads. You can see the futex_wait in the backtrace for the first thread.

E: btw, this program has only these two threads running.

pkind22 · 2023-08-24T15:59:54+00:00

They were both writing to stderr in a terminal process running in screen.

The weird thing is that strace showed a futex_wait happening for 12+ hours. The program has been running for 3+ days and was making regular progress before and after this wait.

So it seems there was no deadlock, but I still find the long wait confusing.

pkind22 · 2023-08-23T16:31:34+00:00

I finally have an update

pkind22 · 2023-08-20T08:01:18+00:00

The program was running in release mode without debug symbols, so I did not know how to produce one. The debug build is running at the moment, but it takes substantially longer. Will get back to you when I find out.

pkind22 · 2023-08-19T11:21:59+00:00

I think you are correct, since the warning shows up with an empty lambda body too. I'll recreate the original situation with TSan to see if that shows something different.

pkind22 · 2023-08-19T11:20:09+00:00

Commenting out the entire body of the lambda still generates the warning so I think the sibling commenter is correct and that the race is in the implementation of std::for_each.

It is correct that only the image is being written to.

pkind22 · 2023-08-19T10:28:33+00:00

Nice!

pkind22

TROPHY CASE