The problem/motivation:

struct X{
char * s;
};

I want to _Static_assert in some point of my code, that
I wrote that code for some specific struct, and if this
struct changes I receive an error in compiler time.

_Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");
free(pX->s);
free(pX);

Ideas to make this practical?
I was thinking about sizeof. One disadvantage is that
it has different finger prints depending on the platform.

Removing item, like deleting s is generally safe because we
need to review the code that stopped to compile.
The problem is when we add something and this also need to
be cleared for instance.

On Wednesday, May 26, 2021 at 7:58:36 AM UTC-7, Thiago Adams wrote:
> The problem/motivation:
>
> struct X{
> char * s;
> };
>
> I want to _Static_assert in some point of my code, that
> I wrote that code for some specific struct, and if this
> struct changes I receive an error in compiler time.
>
> _Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");
> free(pX->s);
> free(pX);
>
> Ideas to make this practical?
> I was thinking about sizeof. One disadvantage is that
> it has different finger prints depending on the platform.
>
> Removing item, like deleting s is generally safe because we
> need to review the code that stopped to compile.
> The problem is when we add something and this also need to
> be cleared for instance.

You're still a dumbass that needs to be banned from using a computer.

On Thursday, May 27, 2021 at 9:32:08 AM UTC-3, The Real Non Homosexual wrote:
> On Wednesday, May 26, 2021 at 7:58:36 AM UTC-7, Thiago Adams wrote:
> > The problem/motivation:
> >
> > struct X{
> > char * s;
> > };
> >
> > I want to _Static_assert in some point of my code, that
> > I wrote that code for some specific struct, and if this
> > struct changes I receive an error in compiler time.
> >
> > _Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");
> > free(pX->s);
> > free(pX);
> >
> > Ideas to make this practical?
> > I was thinking about sizeof. One disadvantage is that
> > it has different finger prints depending on the platform.
> >
> > Removing item, like deleting s is generally safe because we
> > need to review the code that stopped to compile.
> > The problem is when we add something and this also need to
> > be cleared for instance.
> You're still a dumbass that needs to be banned from using a computer.

You didn't said that... But I agree this kind of post is unusual.

But sometimes there is a compiler extensions or someone can
have an idea about it, we never known without asking.

This kind of question does not necessarily needs an answer, but
it can generate other useful discussions.

On Wednesday, 26 May 2021 at 17:58:36 UTC+3, Thiago Adams wrote:
> The problem/motivation:
>
> struct X{
> char * s;
> };
>
> I want to _Static_assert in some point of my code, that
> I wrote that code for some specific struct, and if this
> struct changes I receive an error in compiler time.
>
> _Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");

Source code is not tool to enforce development processes.
Source code is design and low level specification of program.
Development process like reviews should be achieved
with something else.

Am 26.05.21 um 16:58 schrieb Thiago Adams:
> The problem/motivation:
>
> struct X{
> char * s;
> };
>
> I want to _Static_assert in some point of my code, that
> I wrote that code for some specific struct, and if this
> struct changes I receive an error in compiler time.
>
> _Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");
> free(pX->s);
> free(pX);
>
> Ideas to make this practical?
> I was thinking about sizeof. One disadvantage is that
> it has different finger prints depending on the platform.
>
> Removing item, like deleting s is generally safe because we
> need to review the code that stopped to compile.
> The problem is when we add something and this also need to
> be cleared for instance.
>

Maybe you can use check for the last member still being the last?
Something like

struct X {
...
type originally_the_last_member;
}

static_assert (sizeof(X) == offsetof(X, originally_the_last_member) +
sizeof (type));

should work unless there is padding after the last member. Maybe the
apdding can be accounted for usingf some term using alignof?

Philipp

On Thursday, June 3, 2021 at 1:58:47 AM UTC-3, Philipp Klaus Krause wrote:
> Am 26.05.21 um 16:58 schrieb Thiago Adams:
> > The problem/motivation:
> >
> > struct X{
> > char * s;
> > };
> >
> > I want to _Static_assert in some point of my code, that
> > I wrote that code for some specific struct, and if this
> > struct changes I receive an error in compiler time.
> >
> > _Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");
> > free(pX->s);
> > free(pX);
> >
> > Ideas to make this practical?
> > I was thinking about sizeof. One disadvantage is that
> > it has different finger prints depending on the platform.
> >
> > Removing item, like deleting s is generally safe because we
> > need to review the code that stopped to compile.
> > The problem is when we add something and this also need to
> > be cleared for instance.
> >
> Maybe you can use check for the last member still being the last?
> Something like
>
> struct X {
> ...
> type originally_the_last_member;
> }
>
> static_assert (sizeof(X) == offsetof(X, originally_the_last_member) +
> sizeof (type));
>
> should work unless there is padding after the last member. Maybe the
> apdding can be accounted for usingf some term using alignof?
>
> Philipp

Interesting!

Philipp Klaus Krause wrote:
> Am 26.05.21 um 16:58 schrieb Thiago Adams:
>> The problem/motivation:
>>
>> struct X{
>> char * s;
>> };
>>
>> I want to _Static_assert in some point of my code, that
>> I wrote that code for some specific struct, and if this
>> struct changes I receive an error in compiler time.
>>
>> _Static_assert (FINGERPRINT(struct X) != CURRENT_FINGERPRINT, "review this code");
>> free(pX->s);
>> free(pX);
>>
>> Ideas to make this practical?
>> I was thinking about sizeof. One disadvantage is that
>> it has different finger prints depending on the platform.
>>
>> Removing item, like deleting s is generally safe because we
>> need to review the code that stopped to compile.
>> The problem is when we add something and this also need to
>> be cleared for instance.
>>
>
> Maybe you can use check for the last member still being the last?
> Something like
>
> struct X {
> ...
> type originally_the_last_member;
> }
>
> static_assert (sizeof(X) == offsetof(X, originally_the_last_member) +
> sizeof (type));
>
> should work unless there is padding after the last member. Maybe the
> apdding can be accounted for usingf some term using alignof?

If I check for the last member it will not detect if I add
some member before it.

I can also check for the first, in this it will not detect if
I add something in the middle.

Maybe for small structs, this alternative can be practical.

struct X
{ char first;
int middle;
char* last;
};

#define STRUCT_WAS(T, LIST) _Static_assert(sizeof(T) == sizeof(struct
_dummy LIST ), "review")

int main()
{ STRUCT_WAS(struct X, {char first; int middle; char* last; });
}