C / C++ / MFC Discussion Boards

Re: How do you pass an int by reference to a function?

Greg Utas15-Nov-23 5:15

15-Nov-23 5:15

What to do depends on the environment you're running in. I've never used assert, so I had to look up the documentation, which says that it calls abort. Most application code won't catch an invalid_argument exception, so the effect will be similar.

In my open-source software, I neither throw nor assert in this situation. Instead, I generate a debug log with a traceback and return whatever signifies failure if the function has a result. That's appropriate if avoiding crashes is paramount, which is what my software aims for.

You're right that a reference shouldn't be null. For many functions, a pointer argument shouldn't be null either. But applications misbehave, so you have to decide whether your function will check for bad arguments or just crash.

Robust Services Core | Software Techniques for Lemmings | Articles
The fox knows many things, but the hedgehog knows one big thing.

Re: How do you pass an int by reference to a function?

Calin Negru11-Nov-23 5:31

Calin Negru

11-Nov-23 5:31

I got it, thank you.

Struct initalization valid ?

Maximilien7-Nov-23 8:08

Maximilien

7-Nov-23 8:08

I'm looking at old code.

I don't think it's something I ever done.

It seems weird that the compiler accept to not fully initialize the struct.

They (old retired programmers) seem to expect the values to be zero-initialized.

I find it not really safe.

I caught that with the clang/tidy checker.

<h1>define   sz_Potato         "Patate"</h1>

struct MyStruct
{
    int a;
    int b;
    const char* text;
    short c;
};

MyStruct myStructArray[3] =
{
    {1, 2},
    {1, 2, sz_Potato},
    {1, 2, sz_Potato, 4}
};

CI/CD = Continuous Impediment/Continuous Despair

Re: Struct initalization valid ?

Mircea Neacsu7-Nov-23 8:17

Mircea Neacsu

7-Nov-23 8:17

If your code should be compiled as C++ code (not plain C), do yourself a favour and paste a line like:

C++

struct MyStruct
{
  MyStruct () {memset (this, 0, sizeof(MyStruct));} //always initialize your stuff.
    int a;
    int b;
    const char* text;
    short c;
};

Otherwise C initialization rules are vague enough to let you wonder what is going to happen. For instance, in your example, if myStructArray is static, it will get initialized with zeroes. If it's stack allocated, it will be uninitialized.

And to answer your question, yes your code is valid C and C++ code. Not nice but valid.

Mircea

Re: Struct initalization valid ?

Maximilien7-Nov-23 8:39

Maximilien

7-Nov-23 8:39

yeah, I know and will add default contstructors.

Thanks.

Thumbs Up | :thumbsup:

CI/CD = Continuous Impediment/Continuous Despair

Re: Struct initalization valid ?

markkuk7-Nov-23 11:48

markkuk

7-Nov-23 11:48

Maximilien wrote:
It seems weird that the compiler accept to not fully initialize the struct.
They (old retired programmers) seem to expect the values to be zero-initialized.

According to cppreference.com:[^]

Quote:
All members that are not initialized explicitly are empty-initialized.

The old programmers are correct.

Re: Struct initalization valid ?

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

Re: Struct initalization valid ?

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

Re: Struct initalization valid ?

jschell8-Nov-23 6:01

jschell

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')

Re: Struct initalization valid ?

honey the codewitch8-Nov-23 10:03

honey the codewitch

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

Re: Struct initalization valid ?

k50548-Nov-23 12:31

k5054

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

Re: Struct initalization valid ?

honey the codewitch8-Nov-23 21:31

honey the codewitch

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

Re: Struct initalization valid ?

k50549-Nov-23 4:12

k5054

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

Re: Struct initalization valid ?

honey the codewitch9-Nov-23 4:51

honey the codewitch

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

Re: Struct initalization valid ?

k50549-Nov-23 6:49

k5054

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

Not a question, just a lament about metaprogramming

honey the codewitch28-Oct-23 22:19

honey the codewitch

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

Re: Not a question, just a lament about metaprogramming

jschell8-Nov-23 6:06

jschell

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.

Re: Not a question, just a lament about metaprogramming

honey the codewitch8-Nov-23 6:07

honey the codewitch

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

Re: Not a question, just a lament about metaprogramming

jschell9-Nov-23 7:03

jschell

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.

Re: Not a question, just a lament about metaprogramming

honey the codewitch9-Nov-23 7:10

honey the codewitch

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

Re: Not a question, just a lament about metaprogramming

jschell10-Nov-23 5:23

jschell

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.

Re: Not a question, just a lament about metaprogramming

honey the codewitch10-Nov-23 5:37

honey the codewitch

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

Re: Not a question, just a lament about metaprogramming

honey the codewitch8-Nov-23 6:17

honey the codewitch

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

How to extract all words - using regular expression

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

k5054

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

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.