Re: do { quit; } else { }

On 4/8/25 2:04 PM, bart wrote:

On 08/04/2025 18:32, Tim Rentsch wrote:

bart <bc@freeuk.com> writes:
>

On 08/04/2025 15:50, David Brown wrote:
>

On 08/04/2025 13:35, bart wrote:
>

But this need not be the case.  For example this is module A:
>
--------------------------
  #include <stdio.h>
>
  typedef struct point {float a; float b;} Point;
>
  float dist(Point);
>
  int main(void) {
  Point p = {3, 4};
  printf("%f\n", dist(p));
  }
--------------------------
>
And this is module B that defines 'dist':
>
>
--------------------------
  #include <math.h>
>
  typedef float length;
  typedef struct _tag {length x, y;} vector;
>
  length dist(vector p) {return sqrt(p.x*p.x + p.y*p.y);}
--------------------------
>
The types involved are somewhat different, but are compatible
enough for it to work.

>
The two types are entirely compatible.

>
Are they?

>
No, they are not.  The type names 'Point' and 'vector' name two
distinct types, and those types are not compatible, because
the two struct tags are different.
>
Because the two types are not compatible, even just calling the
function dist() is undefined behavior.

 I get an incompatible error (from the example you snipped) even when I remove both struct tags.
 I can't use the same struct tag in the same scope as one will clash with the other. But if I have the second in an inner scope, then I again get the error.
 It doesn't seem to be anything to do with struct tags.
 Two typedefs for same struct layout appear to create distinct types; this fails:
    typedef struct {float x, y;} Point;
   typedef struct {float x, y;} vector;
    Point p;
   vector v;
    p=v;
  But this works:
    typedef struct {float x, y;} Point, vector;
    Point p;
   vector v;
    p=v;
 So it seems to depend on whether Point and vector share the same internal descriptor for the struct.
 In my original example, the structs were defined in separate translation unit, so the compiler has to take things on trust.
>

I think the key point is that every time you define a struct with the struct keyword, it gets a "tag", if you don't provide it, it gets a private unnamable one, that is distinct. Thus you can't define a struct twice and get the exact same type, so every occurance of
struct { float x, y; };
will create a new type, so you can't use one in the place of another.
The "Names" of types in C don't cross transition unit boundries, and it has a rule that two structs, with the same component by component definitions in two different translation units are compatible.
So, in one C file you could have:
typedef struct {float x, y; } Point;
void fun(Point* p) { .... }
and in another C file you could have:
typedef struct { float x, y; } Vector;
extern fun(Vector* v);
Vector v;
...
    fun(&v);
and have fully defined behavior, as the names of the type don't matter in C, just the memory layout.
WITHIN a translation unit, you can't do that as names of types DO matter within a single translation unit,