C / C++ / MFC

Maximilien8-Nov-23 2:32

Maximilien

8-Nov-23 2:32

Thanks.

let's hope 0 or empty strings are not valid values!!
Smile | :)

CI/CD = Continuous Impediment/Continuous Despair

CPallini8-Nov-23 2:37

CPallini

8-Nov-23 2:37

Well, 0 is the best bet. Smile | :)

"In testa che avete, Signor di Ceprano?"
-- Rigoletto

jschell8-Nov-23 6:01

8-Nov-23 6:01

Maximilien wrote:
I'm looking at old code.

You would need to make that more specific.
And provide more context.

Since C didn't initialize them and C++ was initially based on that if it was, for example, code from the 80s then perhaps. But I don't think back then they had array structure initializers.

Maximilien wrote:
seem to expect the values to be zero-initialized.

From "The C++ Programing Language Special Edition" book by Stroustrup with a 2nd Printing of March 2000. I believe that book was based on the first ANSI C++ standard.

Section "4.9.5 Initialization"

"If no initializer is specified ...is initialized to 0 of appropriate type"
"Members of arrays and structures are default initialized or not depending on whether the array or structure is static"

Myself looking at that code, with no other context provided, yes it should be initialized to zero ('text' and 'c')

honey the codewitch8-Nov-23 10:03

8-Nov-23 10:03

I typically use {0} to initialize a struct with a number of fields.

It works. I imagine it can be extended to do the above as you provided, but probably because it fills in remainders with zeroes.

I don't know how unsafe it is. I can tell you it works with GCC, Clang, and MSVC (at least as of 2022) in my experience.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

k50548-Nov-23 12:31

8-Nov-23 12:31

For C code, using {0} is safe, as far as I know, and initializes all bytes of the struct to zero. For C++, I don't know. It looks like maybe all bytes are initialized to zero, as per C, but then constructors are called with an empty argument list. If the first struct member has a constructor, then the compiler will look for a constructor that takes a single int. If no such constructor exists, compilation fails.

Both g++ and clang++ warn about struct members with missing initial values when -Wextra is used.

For C, though, it can be useful, since you can also use named initializers e.g.

struct S {
  int i;
  double d;
  char str[10];
};

struct S s { .d = 123.4; };

will assign 123.4 to s.d, and all other members will be set to zero. You can use named initializers in C++ too, but you still get warnings about struct members with missing initializers.

Keep Calm and Carry On

honey the codewitch8-Nov-23 21:31

8-Nov-23 21:31

Wonder why I don't get any warnings doing that under zephyr, which is pretty darn strict in terms of how it configures GCC. I usually use it to test warnings. I think it's set to -Wall

It's possible I'm not using the {0} technique in any of my major libs, but I could swear I am.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

k50549-Nov-23 4:12

9-Nov-23 4:12

You do need to use -Wextra to get those warnings:

Shell

[k5054@localhost]$ cat example.cpp 
#include <iostream>

struct S
{
    int i;
    float f;
    double d;
};

int main()
{
    S  s{0};

    std::cout << s.f << '\n';
}
[k5054@localhost]$ g++ example.cpp
[k5054@localhost]$ g++ example.cpp -Wall
[k5054@localhost]$ g++ example.cpp -Wextra
example.cpp: In function ‘int main()’:
example.cpp:12:11: warning: missing initializer for member ‘S::f’ [-Wmissing-field-initializers]
   12 |     S  s{0};
      |           ^
example.cpp:12:11: warning: missing initializer for member ‘S::d’ [-Wmissing-field-initializers]
[k5054@localhost]$

Keep Calm and Carry On

honey the codewitch9-Nov-23 4:51

9-Nov-23 4:51

Thank you. I think I'll add that to my build environment.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

k50549-Nov-23 6:49

Not a question, just a lament about metaprogramming

9-Nov-23 6:49

Take a look at the GCC (or clang) documentation for what -Wextra adds: Warning Options (Using the GNU Compiler Collection (GCC)) . In most cases, you probably do want to be aware of all the additional warnings that -Wextra brings. But maybe in the embedded world you're going to be doing something that's going to trigger one of the warnings excessively. In which case you might just want -Wmissing-field-initializers. Or perhaps you might want e.g. -Wextra -Wno-unintialized, which gives you all of -Wextra's goodness, but silences the -Wuninitailzed warnings.

If you've got a section of code that you know is going to generate warnings, and you just want to shut the compiler up you can always investigate the GCC diagnostic pragmas : Diagnostic Pragmas (Using the GNU Compiler Collection (GCC))

Keep Calm and Carry On

honey the codewitch28-Oct-23 22:19

Re: Not a question, just a lament about metaprogramming

28-Oct-23 22:19

I love C++ because I can do things like this:

C++

// creates a BGRx pixel by making each channel 
// one quarter of the whole. Any remainder bits
// are added to the green channel. One channel
// is unused. Consumed by DirectX
template<size_t BitDepth>
using bgrx_pixel = gfx::pixel<
	gfx::channel_traits<gfx::channel_name::B,(BitDepth/4)>,
    gfx::channel_traits<gfx::channel_name::G,((BitDepth/4)+(BitDepth%4))>,
    gfx::channel_traits<gfx::channel_name::R,(BitDepth/4)>,
	gfx::channel_traits<gfx::channel_name::nop,(BitDepth/4),0,(1<<(BitDepth/4))-1,(1<<(BitDepth/4))-1>    
>;
using screen_t = uix::screen<gfx::bgrx_pixel<32>>;

Now, I've made pixels definable in terms of their memory footprint and what channels they expose, like R, G and B, or C, Y, and Mk or whatever. Above I'm defining a BGRx8888 pixel which DirectX uses for its surfaces. That's 3 8-bit channels with a fourth unused, blue first.

The above code is facilitated by this: gfx/include/gfx_pixel.hpp at master · codewitch-honey-crisis/gfx · GitHub[^]

That defines things like channel traits, and does all the necessary compile time computations to make it work.

The problem is this: It's write-only code, and there's no easy way to remedy it because meta-programming in C++17 and prior is very hackish. C++20 and beyond improve the situation a little, but the heavy reliance on The STL rather than language improvements to facilitate this leaves me wanting on little embedded platforms where the STL might not be complete or even available.

It's cool that with C++ you can even make facilities to enable code like the above, and it's the only language I know of that allows for it, but I really wish there was a cleaner way to do this stuff. Unsure | :~

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

jschell8-Nov-23 6:06

Re: Not a question, just a lament about metaprogramming

8-Nov-23 6:06

honey the codewitch wrote:
there was a cleaner way to do this stuff

I give up...why is this specific bit of code better as a template versus a method?

To me a method would be cleaner. And it would allow you to do what you want.

honey the codewitch8-Nov-23 6:07

Re: Not a question, just a lament about metaprogramming

8-Nov-23 6:07

A method would precompute the arbitrary bitshifts needed to craft a bitmap with the appropriate binary footprint, set individual arbitrary color channels, etc, at compile time? AFAIK a method cannot define a type.

constexpr won't do that. It must be some C++20 or beyond feature I'm not aware of, but to solve this problem in C++17 requires a template.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

jschell9-Nov-23 7:03

Re: Not a question, just a lament about metaprogramming

9-Nov-23 7:03

honey the codewitch wrote:
It must be some C++20 or beyond feature I'm not aware of

Not at all.

So you want to use certain fixed values in your code, but you don't want to compute them (presumably manually.)

So write an executable that outputs those values as code statements. I suspect
1. That executable (the code) is more obvious in its purpose
2. It can be modified to do the part that you claim is missing.
3. It will make the target code less confusing.

You can even make the execution of that executable part of your build process.

honey the codewitch9-Nov-23 7:10

Re: Not a question, just a lament about metaprogramming

9-Nov-23 7:10

I'm not using a code generator. C++ already has one built in. It's called template and that's literally what it's designed to do.

Anyway, I'd rather deal with it's weirdness than write code generators for everything, at which point I'd just use C because template and constexpr are the only reason I care about C++ over C.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

jschell10-Nov-23 5:23

Re: Not a question, just a lament about metaprogramming

10-Nov-23 5:23

honey the codewitch wrote:
I'm not using a code generator. C++ already has one built in. It's called template and that's literally what it's designed to do.

Rather certain that is not why they were specifically added to the language.

The fact that you can do that is ok. Just not what they exist for.

Following agrees with my understanding of the addition.

Template (C++) - Wikipedia[^]

"Major inspirations for C++ templates were the parameterized module"

honey the codewitch wrote:
I'd rather deal with it's weirdness than write code generators for everything

One case doesn't mean you would need to to it for all.

And your lament is that it does not have all the functionality you would like for this specific situation. So you can hack around it or find another solution.

honey the codewitch wrote:
Anyway, I'd rather deal

Again this is another difference in domain spaces. Maintenance for you is based on what you do because that is the business model that you have created.

For me I must consider how others will maintain what I have created. So for complex solutions I must consider the totality of what some future developer might be dealing with when they look at my code. So I would consider a one off module as being more understandable rather than perhaps several different code paths to work around to a potential solution.

honey the codewitch10-Nov-23 5:37

Re: Not a question, just a lament about metaprogramming

10-Nov-23 5:37

I do use code generation where template won't suffice, like generating state machines, but it complicates the build process.

In the end metaprogramming evolved from simple GP without intrinsic language support for it and that is ultimately what I'm complaining about.

Newer iterations of C++ post say 20 are starting to rectify this, and make the concepts more "first class"

That will improve readability without complicating the build.

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

honey the codewitch8-Nov-23 6:17

How to extract all words - using regular expression

8-Nov-23 6:17

Forgive the multiple replies but I think maybe I'm not explaining the above.

That is user code in the OP. That defines a pixel type that DirectX can consume.

There are others. I've pasted a swath of additional definitions for other types of pixels that are commonly used in my library.

You can then take a pixel type and do like this

using fb_t = bitmap<bgrx_pixel<32>>;<br />
uint8_t fb_buffer[fb_t::sizeof_buffer(screen_size)];<br />
fb_t fb(screen_size,fb_buffer);

Then when you proceed to draw to fb it's begin() method (pointing to fb_buffer in this case) contains bitmap data of that format based on the definition in the OP.

If it was an 18 bit pixel, as some weird graphics devices support, it would do that too. They aren't necessarily even on clean byte boundaries.

Forgive the following, but hopefully it provides useful context

C++

// creates an RGB pixel by making each channel 
    // one third of the whole. Any remainder bits
    // are added to the green channel
    template<size_t BitDepth>
    using rgb_pixel = pixel<
        channel_traits<channel_name::R,(BitDepth/3)>,
        channel_traits<channel_name::G,((BitDepth/3)+(BitDepth%3))>,
        channel_traits<channel_name::B,(BitDepth/3)>
    >;
    // creates an RGBA pixel by making each channel 
    // one quarter of the whole. Any remainder bits
    // are added to the green channel
    template<size_t BitDepth>
    using rgba_pixel = pixel<
        channel_traits<channel_name::R,(BitDepth/4)>,
        channel_traits<channel_name::G,((BitDepth/4)+(BitDepth%4))>,
        channel_traits<channel_name::B,(BitDepth/4)>,
        channel_traits<channel_name::A,(BitDepth/4),0,(1<<(BitDepth/4))-1,(1<<(BitDepth/4))-1>
    >;
    // creates a grayscale or monochome pixel
    template<size_t BitDepth>
    using gsc_pixel = pixel<
        channel_traits<channel_name::L,BitDepth>
    >;
    // creates a Y'UV pixel by making each channel 
    // one third of the whole. Any remainder bits
    // are added to the Y' channel
    template<size_t BitDepth>
    using yuv_pixel = pixel<
        channel_traits<channel_name::Y,((BitDepth/3)+(BitDepth%3))>,
        channel_traits<channel_name::U,(BitDepth/3)>,
        channel_traits<channel_name::V,(BitDepth/3)>
    >;
    // creates a Y'UV/A pixel by making each 
    // channel 1/4 of the whole. Remaining bits
    // are added to Y'
    template<size_t BitDepth>
    using yuva_pixel = pixel<
        channel_traits<channel_name::Y,((BitDepth/4)+(BitDepth%4))>,
        channel_traits<channel_name::U,(BitDepth/4)>,
        channel_traits<channel_name::V,(BitDepth/4)>,
        channel_traits<channel_name::A,(BitDepth/4),0,(1<<(BitDepth/4))-1,(1<<(BitDepth/4))-1>
    >;

    // creates a YCbCr pixel by making each channel 
    // one third of the whole. Any remainder bits
    // are added to the Y channel
    template<size_t BitDepth>
    using ycbcr_pixel = pixel<
        channel_traits<channel_name::Y,((BitDepth/3)+(BitDepth%3))>,
        channel_traits<channel_name::Cb,(BitDepth/3)>,
        channel_traits<channel_name::Cr,(BitDepth/3)>
    >;
    // creates a ycbcr pixel by making each 
    // channel 1/4 of the whole. Remaining bits
    // are added to Y
    template<size_t BitDepth>
    using ycbcra_pixel = pixel<
        channel_traits<channel_name::Y,((BitDepth/4)+(BitDepth%4))>,
        channel_traits<channel_name::Cb,(BitDepth/4)>,
        channel_traits<channel_name::Cr,(BitDepth/4)>,
        channel_traits<channel_name::A,(BitDepth/4),0,(1<<(BitDepth/4))-1,(1<<(BitDepth/4))-1>
    >;
    // creates an indexed pixel
    template<size_t BitDepth>
    using indexed_pixel=pixel<channel_traits<channel_name::index,BitDepth>>;
    
    // creates a HSV pixel by making each channel 
    // one third of the whole. Any remainder bits
    // are added to the V channel
    template<size_t BitDepth>
    using hsv_pixel = pixel<
        channel_traits<channel_name::H,(BitDepth/3)>,
        channel_traits<channel_name::S,(BitDepth/3)>,
        channel_traits<channel_name::V,((BitDepth/3)+(BitDepth%3))>
    >;
    // creates a HSV/A pixel by making each 
    // channel 1/4 of the whole. Remaining bits
    // are added to V
    template<size_t BitDepth>
    using hsva_pixel = pixel<
        channel_traits<channel_name::H,(BitDepth/4)>,
        channel_traits<channel_name::S,(BitDepth/4)>,
        channel_traits<channel_name::V,((BitDepth/4)+(BitDepth%4))>,
        channel_traits<channel_name::A,(BitDepth/4),0,(1<<(BitDepth/4))-1,(1<<(BitDepth/4))-1>
    >;

Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix

Salvatore Terress26-Oct-23 6:35

Salvatore Terress

26-Oct-23 6:35

EDIT
OK using g - as in "global" shoud work , but it does not

result = BTUL->EditLine_RegExp(result, "(\\w+ \g)");

Where is my error ??

I am having mental block - forgot how to add " match all words ":.
Here is my failing attempt to do so

result = BTUL->EditLine_RegExp(result, "(\\w+*)" );

Can somebody help me to modify my regular expression to
match all words

PLEASE
No references to AI regular expression generators
- they do not do well multiple entries.

modified 26-Oct-23 13:23pm.

Re: How to extract all words - using regular expression

k505426-Oct-23 7:21

Re: How to extract all words - using regular expression

26-Oct-23 7:21

Are you sure you want \w That includes 0-9 and underscore (_), as well as alphabetic characters, which may not be what you want.

Is your intention to capture a set of all words in the input text? Is that what BTUL->EditLine_RegExp() does? I googled for EditLine_RegExp, and got precisely zero results, so maybe you can explain where that comes from and what it returns?

Keep Calm and Carry On

Richard Andrew x6426-Oct-23 8:51

Richard Andrew x64

26-Oct-23 8:51

Try this:

Match all words[^]

The difficult we do right away...
...the impossible takes slightly longer.

Re: How to extract all words - using regular expression

Richard MacCutchan26-Oct-23 22:16

Richard MacCutchan

26-Oct-23 22:16

The following will find all words:

/\w+/g

You can test it quite quickly at RegExr: Learn, Build, & Test RegEx[^].

But it would help if you showed us the actual text you are working with, and the results you get.

And please use <pre> tags around the code parts so your question is clear.

Re: How to extract all words - using regular expression

Salvatore Terress27-Oct-23 10:21

Salvatore Terress

27-Oct-23 10:21

Many thanks for all the support.

FYI
I did use "[ -~]+" to extract first continuous words. Now I am working on to extract ALL words...

I did try pass "[/\w+/g]+" to my otherwise working function and ended up with [/w+/g]+
- the back slash is missing,

And this is result , part of my debug messages

" instring text  \t\n Waiting to connect to bluetoothd..."
" regular expression \t\n  [/w+/g]+"
" Has all match g"

You asked for the string I am trying to extract stuff from

here it is

"Waiting to connect to bluetoothd...\r\u001B[0;94m[bluetooth]\u001B[0m#                                                                              \r\r\u001B[0;94m[bluetooth]\u001B[0m# \r                        \rAgent registered\n\u001B[0;94m[bluetooth]\u001B[0m# "

As you can see - the extracted "g" is from "Agent". No good...

I suspect Qt is messing with passing the backslash...

C++

        // result = BTUL->EditLine_RegExp_Ext(result, "[ -~]+",textEditPtr_DEBUG, textEditPtr_DEBUG);
       result = BTUL->EditLine_RegExp_Ext(result, "[/\w+/g]+",textEditPtr_DEBUG, textEditPtr_DEBUG);

<pre lang="C++">

"Waiting to connect to bluetoothd..."
"Waiting to connect to bluetoothd..."
"START EditLine_RegExp...QString BT_Utility_Library::EditLine_RegExp_Ext(QString, QString, QTextEdit *, QTextEdit *)1321"
" instring text  \t\n Waiting to connect to bluetoothd..."
" regular expression \t\n  [/w+/g]+"
" Has all match g"

Re: How to extract all words - using regular expression

Richard MacCutchan27-Oct-23 22:13

Richard MacCutchan

27-Oct-23 22:13

The backslash character is used as the escape character within strings, so you need to escape it:

"[/\\w+/g]+"

Re: How to extract all words - using regular expression

jschell27-Oct-23 10:11