Printable View
hello everyone !
I just wanted to know of there exist a way of comparing two values whose type is created by the programmer without having to compary all the structure's members ? (for eg , to compare string we user strcmp....)
suppose we have this structure (record) :
how to compare var1 and var1 ?Code:typedef struct{
int a,
char b[];
double c;
}var1, var2;
You can write a function to compare those however you like as there are many ways of doing it. It all depends on what those variables mean.
For example, if b was a person's name, c was their birthdate, and a was their favourite colour, then one reasonable way to define a comparison function might be:Note that b takes no part in the comparison here because it doesn't make sense for the array in question to have two people with the same name and the same birthdate, but with a different favourite colour.Code:int compare(myStruct *l, myStruct *r)
{
int cmp = strcmp(l->b, r->b);
if (cmp != 0) return cmp;
if (l->c < r->c) return -1;
if (l->c > r->c) return 1;
return 0;
}
In order to know how you want YOUR data compared, you'll have to post a REAL struct definition.
I'm pretty sure that you can't declare an array without a size, except as the last item in a struct (even then only on some compilers).
Problem in declaring unknown sized array is a fundamental feature in C. It returns to the very basics of C and memory.
The structs, variables, everything is just data in memory, starting from certain location, and continuing to certain amount of bytes. And when you handle, lets say a struct, the place of certain members is calculated based on the definition of a struct. Compiler needs to know the size of the struct members, in order to be able to calculate the starting address of the next member.
However, if you know the size of a struct, you can compare it to another struct by just comparing the data from the starting adresses of the struct, untill the sizeof struct. You can do that easily in a loop, or with some standard functions like memcmp()
would that work? would be cool if it does, but I would have thought that it wouldent as structs arent null terminated. Maybe strncmp with sizeof(myStruct)Code:int compare(myStruct *l, myStruct *r)
{
int cmp = strcmp(l->b, r->b);
if (cmp != 0) return cmp;
if (l->c < r->c) return -1;
if (l->c > r->c) return 1;
return 0;
}
Structs don't need to be null terminated, themselves - they are accessed by the size of their members which is known by the definition of the struct.
A char array, inside a struct, can be marked with an end-of-string char, of course.
BTW, Mike. Did you finish your Tic-Tac-Toe game?
When I was writing up my TTT game, I found out I had only learned *one* of the three winning tricks in TTT, as a kid. I was taken aback, to be sure!
How does this even compile? You can't have a array without a specified size in the middle of a struct. Also, you are declaring var1 and var2 as type synonyms, not variables.Quote:
Originally Posted by sleepywalker
Nah, i never bothered writing the game logic for it as thats not all that fun, and I dont think anyone would want to play the game anyway, lol. So i kinda dropped it after dealing with the move evaluation. I wrote an Othello game in Java using swing after that, which can be played 2 player and plan on adding AI to it when I get time.Quote:
BTW, Mike. Did you finish your Tic-Tac-Toe game?
When I was writing up my TTT game, I found out I had only learned *one* of the three winning tricks in TTT, as a kid. I was taken aback, to be sure!
That works for comparing to see if two structs are equal. For any "greater/lesser than" it is unlikely to work - the reason being that it simply compares bytes until it finds either the end or a byte that is different [it may well do this in a way that assumes largely equality and compares LARGE chunks, e.g. 8 or 16 bytes at a time, and only resorts to comparing individual bytes when it's found a chunk that is different]. This really only works for strings and other arrays of bytes. For any other data structure, there are two problems:Quote:
Originally Posted by Maz
1. There may be gaps for alignment purposes in the structure that aren't filled in at all - so random bytes will disrupt the comparison, but do not actually contain valid data.
2. Integer values are not always stored "big endian", and a little-endian value of 255 is "greater" than 16777216 - which of course isn't what you want if you want to know if x.a > y.a.
3. If the structure contains pointers, it would be impossible to compare that in this way - that will ABSOLUTELY have to be compared a different way (unless you actually want to know if all pointers are pointing to the same place, rather than if they are pointing to equal content).
--
Mats
--
Mats
I can't see any reason for not comparing the struct member for member, as in x.m1==y.m1, x.m2==y.m2 and so on. On a sidenote, it's certainly not possible to write a generic struct comparing function.
There is no winning trick in TTT.Quote:
When I was writing up my TTT game, I found out I had only learned *one* of the three winning tricks in TTT, as a kid.
TTT is a 2-player finite zero-sum game with perfect information, hence there exists an optimal strategy, the minimax algorithm. When playing against a perfect player, the best you can hope for is a tie.
The same applies to other such games like go and chess, but there it's harder to become a perfect player.
Greets,
Philip
Code:typedef struct{
int a;
char b[10];
double c;
} bard;
bard thee,summersDay;
if ( memcmp( &thee, &summersDay ) == 0 ) {
}
Of course it is. You can construct a list of elements of an object, and write a generic function that compares two structures arbitrarily according to some generic rules. A structure like this would work:Quote:
Originally Posted by Snafuist
Obviously, we'll need to make suitable pointer arithmetics to figure out the rest of the functions.Code:typedef { VOID = 0, INT, STR, CHAR, CHARPTR, FLOAT, DOUBLE } EType;
typedef struct SElement
{
char *name; // Not actually needed - just because the macro CAN DO THAT.
offset_t offs;
enum EType type;
} Element;
typedef struct SExample
{
int a;
char *str1;
char str2[40];
char b;
} Example;
#define ELEM(structname, name, type) { #name, offsetof(structname, name), type }
Element ExampleDescr [] =
{
ELEM(Example, a, INT),
ELEM(Example, str1, CHARPTR),
ELEM(Example, str2, STR),
ELEM(Example, b, CHAR)
};
int CompareStructsGeneric(void *struct1, void *struct2, Element descr, size_t nElements)
{
for(i = 0; i < nElements; i++)
{
switch(descr[i].type)
{
case INT:
if (*(int *)((char*)struct1+descr[i].offset) > *(int *)((char*)struct2+descr[i].offset)
return 1;
else if (*(int *)((char*)struct1+descr[i].offset) < *(int *)((char*)struct2+descr[i].offset)
return -1;
break; /* Equal, continue to next element ... */
....
}
}
return 0;
}
But you could certainly use this mechanism to compare completely arbitrary structures, as long as they are both the same type.
--
Mats
No, it's not.Quote:
Of course it is.
Give me a complete implementation of a struct comparing function and I'll make up a struct which it can't compare. Think of typedef.
Greets,
Philip
Well, of course, if you have nested structures (or pointers to structures), you'd need to have a hierarchical structure to support that. Again, it's certainly POSSIBLE to do. Just a bit more complicated - we'd need to add at least one more field to the structure describing the struct and of course, more fields to the enum.Quote:
Originally Posted by Snafuist
I doubt that typedef will change anything in itself - it is just a way to alias one type to another name.
If you don't believe me, please post a structure you think we can't deal with, and I'll see if I can't find a solution.
Note that the above is simply enough to convey the architecture of a struct comparing function - it can (and probably will) be made MUCH more complex if you need to actually do this in the real world. But I'm still convinced it CAN be done.
And if all else fails, we can always extend the structure describing each struct by adding a function-pointer that takes the pointer to the current element - that way, you can have "user" types that can be compared in any way the user wishes.
Whether it is actually MEANINGFUL to do it is of course another matter altogether.
And, before you say so, I would agree that structs containing unions can be quite tricky - since you'd have to know which variant of the possible members we should look at. Bitfields would also not work - but most people don't use bitfields very often anyways.
--
Mats
I completely agree to most of what you say, it's true for native types and compound types. Your implementation will actually work fairly well on all real world examples I can think of right now. We just have a different opinion on the purpose of typedef:
That's what #define is used for. The typedef keyword actually defines a new type, probably inventing new semantics.Quote:
I doubt that typedef will change anything in itself - it is just a way to alias one type to another name.
I'm free to do "typedef int foo" and constitute that all even values in the range of foo have the same meaning (say, "bar"), while all odd values in the range of foo have the same meaning as there integer counterpart.
Now if I have two variables x and y of type foo where x==2 and y==4, then they shall compare equal. For your struct comparing function to return correct results, I need to modify the enum and the function definition. But then, it wasn't generic in the first place.
I admit that this example is a bit artificial (ok, it's highly artificial), and as I said before, in real world situations your approach is perfectly fine. From a theoretical viewpoint however, it's not possible.
I know I sound ..........y. Just forget about it, I greatly admire your knowledge and I'm certainly not trying to annoy you.
Greets,
Philip
Typedef on it's own will not achieve that - typedef is just a way to say "when I use type X, I want you (the compiler) to see that as <whatever>". In fact, if you use "typedef int foo", the compiler will quite happily pass int and foo types to functions that take foo and int types respectevily, with no restriction. foo is a type in its own right, but it has the same properties and behaviour as int. The only difference is that if you wish to change foo into some other type (long, long long, short, double or some struct), it can easily be done with just changing one typdef line, rather than trying to find all places where "int" is being used.Quote:
Originally Posted by Snafuist
To have all even numbers in a different range than odd numbers, you either need C++ classes (which is not available in C), or use some sort of macro/function to compare numbers of that type - but the compiler will not let you simply re-define the meaning of int by calling it foo instead.
And no, I don't get that easily annoyed or anything - if you had come up with something that would NOT work, then I would have acknowledged you (you may still have thought of something I haven't - I have never actually WRITTEN a function that does what I described above - I have written other functions that do SIMILAR things, but usually on a restricted set of things).
--
Mats
If anyone ever wants to compare structs using the method I described above, here's some code that actually compiles and tests as far as the testcases here allow:
Note, I know goto and fall-through switches is bad. Doing lots of duplication of code is ALSO bad - it's a balance, and I'm not feeling like typing a lot more than necessary, so went for the first nasty variant rather than the second one. [All of the non-string comares could also be turned into a multiline macro, but I do not like multiline macros much, so since it's actually OK to write it out, I did].Code:#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
typedef enum { VOID = 0, INT, CHARARRAY, CHAR, CHARPTR, FLOAT, DOUBLE, STRUCT, STRUCTPTR } EType;
typedef ptrdiff_t offset_t;
typedef struct SElement
{
char *name; // Not actually needed - just because the macro CAN DO THAT.
offset_t offs;
enum EType type;
} Element;
typedef struct SExample
{
int a;
char *str1;
char str2[40];
char b;
} Example;
#define ELEM(structname, name, type) { #name, offsetof(structname, name), type }
Element exampleDescr [] =
{
ELEM(Example, a, INT),
ELEM(Example, str1, CHARPTR),
ELEM(Example, str2, CHARARRAY),
ELEM(Example, b, CHAR)
};
typedef struct SExample2
{
int a;
float f;
double d;
char b;
} Example2;
Element example2Descr[] =
{
ELEM(Example2, a, INT),
ELEM(Example2, f, FLOAT),
ELEM(Example2, d, DOUBLE),
ELEM(Example2, b, CHAR)
};
int CompareStructsGeneric(void *struct1, void *struct2, Element *descr, size_t nElements)
{
size_t i;
for(i = 0; i < nElements; i++)
{
void *elem1, *elem2;
int cmp;
char *s1, *s2;
double d1, d2;
elem1 = (char *)struct1 + descr[i].offs;
elem2 = (char *)struct2 + descr[i].offs;
switch(descr[i].type)
{
case INT:
if (*(int *)elem1 > *(int *)elem2)
return 1;
else if (*(int *)elem1 < *(int *)elem2)
return -1;
break; /* Equal, continue to next element ... */
case CHAR:
if (*(char*)elem1 > *(char*)elem2)
return 1;
else if (*(char*)elem1 < *(char*)elem2)
return -1;
break; /* Equal, continue to next element ... */
case FLOAT:
d1 = *(float *)elem1;
d2 = *(float *)elem2;
// Avoid code duplication at expense of using goto!
goto fcompare;
case DOUBLE:
d1 = *(double *)elem1;
d2 = *(double *)elem2;
fcompare:
if (d1 > d2)
return 1;
else if (d1 < d2)
return -1;
break;
case CHARPTR:
elem1 = *(char **)elem1;
elem2 = *(char **)elem2;
// Clever-tricks: fall-throug!
case CHARARRAY:
s1 = elem1;
s2 = elem2;
cmp = strcmp(s1, s2);
if (cmp) return cmp;
break;
default:
printf("Incorrect or unimplemented case: %d\n", descr[i].type);
break;
}
}
return 0;
}
Example a = { 1, "Hello", "World!", 'a' };
Example b = { 2, "Hello", "World!", 'b' };
Example c = { 1, "Hello", "World!", 'a' };
Example d = { 1, "Hello", "World!", 'd' };
Example2 a2 = { 1, 5.0f, 6.0, 'a' };
Example2 b2 = { 1, 5.1f, 6.0, 'a' };
Example2 c2 = { 1, 5.0f, 6.0-0.001, 'a' };
struct TestCase
{
char *name;
void *s1, *s2;
Element *descr;
size_t nelem;
int res;
};
#define ARRAYSIZE(x) (sizeof(x)/sizeof((x)[0]))
#define TC(name, s1, s2, ds, res) { #name, &s1, &s2, ds, ARRAYSIZE(ds), res }
struct TestCase testCases[] =
{
TC(equal1, a, a, exampleDescr, 0),
TC(equal2, a, c, exampleDescr, 0),
TC(greater1, b, a, exampleDescr, 1),
TC(lesser1, a, b, exampleDescr, -1),
TC(equal3, a2, a2, example2Descr, 0),
TC(equal3, a2, a2, example2Descr, 0),
TC(greater2, b2, a2, example2Descr, 1),
TC(lesser2, c2, a2, example2Descr, -1),
TC(lesser3, a, d, exampleDescr, -1)
};
void expect(const char *name, int expected, int res)
{
if (res != expected)
{
printf("%s: Expected %d, got %d\n", name, expected, res);
}
}
int main()
{
int i;
for(i = 0; i < ARRAYSIZE(testCases); i++)
{
int res;
printf("Performing test-case %s\n", testCases[i].name);
res = CompareStructsGeneric(testCases[i].s1, testCases[i].s2, testCases[i].descr, testCases[i].nelem);
expect(testCases[i].name, testCases[i].res, res);
}
return 0;
}
--
Mats