Compare a given version number in the form major.minor.build.patch and see if one is less than the other





.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ margin-bottom:0;
}







2












$begingroup$


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef int STATUS;
#define ERROR -1
#define OKAY 0

struct version
{
unsigned char major;
unsigned char minor;
unsigned char build;
unsigned char patch;
};
STATUS is_less_than(struct version * original, struct version *compared, bool *result)
{
if(original == NULL || compared == NULL || result == NULL)
{
result = NULL;
return ERROR;
}
*result = false;

if(original->major < compared->major)
{
*result = true;
}
else if(original->major == compared->major) // else if the major >= major
{

if(original->minor < compared->minor)
{
*result = true;
}
else if(original->minor == compared->minor)
{
if(original->build < compared->build)
{
*result = true;
}
else if(original->build == compared->build)
{
if(original->patch < compared->patch)
{
*result = true;
}
else if(original->patch == compared->patch)
{
*result = false;
}
}
}
}


return OKAY;

}


Is there a cleaner way to do this?










share|improve this question









$endgroup$



















    2












    $begingroup$


    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdbool.h>

    typedef int STATUS;
    #define ERROR -1
    #define OKAY 0

    struct version
    {
    unsigned char major;
    unsigned char minor;
    unsigned char build;
    unsigned char patch;
    };
    STATUS is_less_than(struct version * original, struct version *compared, bool *result)
    {
    if(original == NULL || compared == NULL || result == NULL)
    {
    result = NULL;
    return ERROR;
    }
    *result = false;

    if(original->major < compared->major)
    {
    *result = true;
    }
    else if(original->major == compared->major) // else if the major >= major
    {

    if(original->minor < compared->minor)
    {
    *result = true;
    }
    else if(original->minor == compared->minor)
    {
    if(original->build < compared->build)
    {
    *result = true;
    }
    else if(original->build == compared->build)
    {
    if(original->patch < compared->patch)
    {
    *result = true;
    }
    else if(original->patch == compared->patch)
    {
    *result = false;
    }
    }
    }
    }


    return OKAY;

    }


    Is there a cleaner way to do this?










    share|improve this question









    $endgroup$















      2












      2








      2





      $begingroup$


      #include <stdio.h>
      #include <stdlib.h>
      #include <string.h>
      #include <stdbool.h>

      typedef int STATUS;
      #define ERROR -1
      #define OKAY 0

      struct version
      {
      unsigned char major;
      unsigned char minor;
      unsigned char build;
      unsigned char patch;
      };
      STATUS is_less_than(struct version * original, struct version *compared, bool *result)
      {
      if(original == NULL || compared == NULL || result == NULL)
      {
      result = NULL;
      return ERROR;
      }
      *result = false;

      if(original->major < compared->major)
      {
      *result = true;
      }
      else if(original->major == compared->major) // else if the major >= major
      {

      if(original->minor < compared->minor)
      {
      *result = true;
      }
      else if(original->minor == compared->minor)
      {
      if(original->build < compared->build)
      {
      *result = true;
      }
      else if(original->build == compared->build)
      {
      if(original->patch < compared->patch)
      {
      *result = true;
      }
      else if(original->patch == compared->patch)
      {
      *result = false;
      }
      }
      }
      }


      return OKAY;

      }


      Is there a cleaner way to do this?










      share|improve this question









      $endgroup$




      #include <stdio.h>
      #include <stdlib.h>
      #include <string.h>
      #include <stdbool.h>

      typedef int STATUS;
      #define ERROR -1
      #define OKAY 0

      struct version
      {
      unsigned char major;
      unsigned char minor;
      unsigned char build;
      unsigned char patch;
      };
      STATUS is_less_than(struct version * original, struct version *compared, bool *result)
      {
      if(original == NULL || compared == NULL || result == NULL)
      {
      result = NULL;
      return ERROR;
      }
      *result = false;

      if(original->major < compared->major)
      {
      *result = true;
      }
      else if(original->major == compared->major) // else if the major >= major
      {

      if(original->minor < compared->minor)
      {
      *result = true;
      }
      else if(original->minor == compared->minor)
      {
      if(original->build < compared->build)
      {
      *result = true;
      }
      else if(original->build == compared->build)
      {
      if(original->patch < compared->patch)
      {
      *result = true;
      }
      else if(original->patch == compared->patch)
      {
      *result = false;
      }
      }
      }
      }


      return OKAY;

      }


      Is there a cleaner way to do this?







      c






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked 5 hours ago









      the_endianthe_endian

      396212




      396212






















          3 Answers
          3






          active

          oldest

          votes


















          2












          $begingroup$

          Yes, there is a cleaner way:



          if (a.major != b.major) {
          *result = a.major < b.major;
          } else if (a.minor != b.minor) {
          *result = a.minor < b.minor;
          } else if (a.patch != b.patch) {
          *result = a.patch < b.patch;
          } else {
          *result = a.build < b.build;
          }
          return OKAY;


          I reordered patch to come before build since that's how it is usually done. If your version scheme is different from this, good luck.



          Instead of unsigned char I would choose unsigned int so that your code can handle versions like 1.0.20190415.






          share|improve this answer











          $endgroup$













          • $begingroup$
            Nice catch on the patch, build ordering.
            $endgroup$
            – Costantino Grana
            1 hour ago



















          0












          $begingroup$

          Return status



          You create this:



          typedef int STATUS;
          #define ERROR -1
          #define OKAY 0


          which is basically a boolean status. Personally, I'd return a straight bool.



          Bug/Not what you mean



          Doing a



          result = NULL;


          is changing the local variable (parameter) result. It's not setting the result to NULL. In fact the caller won't probably have a pointer at all, but just a bool, which cannot properly be NULL.



          Shorter version



          I'm not sure this is cleaner, but here I go:



          bool is_less_than(struct version * original, struct version *compared, bool *result)
          {
          if(original == NULL || compared == NULL || result == NULL)
          return false;

          *result = original->major < compared->major || original->major == compared->major && (
          original->minor < compared->minor || original->minor == compared->minor && (
          original->build < compared->build || original->build == compared->build && (
          original->patch < compared->patch)));

          return true;
          }


          Next time, add a driver/test suite to your question, to ease the life of people answering. This can be one:



          int main(void) 
          {
          struct version ref = { 1, 2, 21, 8 };
          struct version lower1 = { 0, 2, 21, 8 };
          struct version lower2 = { 1, 1, 21, 8 };
          struct version lower3 = { 1, 2, 20, 8 };
          struct version lower4 = { 1, 2, 21, 7 };
          struct version equal = { 1, 2, 21, 8 };
          struct version higher1 = { 2, 2, 21, 8 };
          struct version higher2 = { 1, 3, 21, 8 };
          struct version higher3 = { 1, 2, 22, 8 };
          struct version higher4 = { 1, 2, 21, 9 };

          #define TEST(a,b,expect1,expect2)
          do {
          bool result1, result2;
          is_less_than((a), (b), &result1);
          is_less_than((b), (a), &result2);
          puts(result1==(expect1) && result2==(expect2)?"ok":"failed");
          } while(0)
          #define TESTL(a,b) TEST(a,b,true,false)
          #define TESTE(a,b) TEST(a,b,false,false)
          #define TESTH(a,b) TEST(a,b,false,true)

          TESTL(&lower1, &ref);
          TESTL(&lower2, &ref);
          TESTL(&lower3, &ref);
          TESTL(&lower4, &ref);
          TESTE(&equal, &ref);
          TESTH(&higher1, &ref);
          TESTH(&higher2, &ref);
          TESTH(&higher3, &ref);
          TESTH(&higher4, &ref);

          return 0;
          }





          share|improve this answer











          $endgroup$









          • 1




            $begingroup$
            As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
            $endgroup$
            – Roland Illig
            1 hour ago












          • $begingroup$
            @RolandIllig Updated. Thank you for the suggestion.
            $endgroup$
            – Costantino Grana
            1 hour ago



















          0












          $begingroup$

          I don't see any advantage to having the function to take three pointers (two for input and one for output) and return a status code. As a result of that unnecessarily error-prone design, the function has to handle the possibility of null pointers, and the caller is expected to handle a status code. But why should such a simple comparison have these failure modes at all?



          The danger is further complicated by the fact that neither of the in-parameters is declared const.



          Just pass the two versions by value, and you would eliminate all of that complication! On any modern 32-bit or 64-bit processor, passing a four-byte struct by value should actually be more efficient than passing it by reference — especially since you don't have to dereference the pointers to access each field.



          With all of the potential errors out of the way, taking @RolandIllig's suggestion, you could then reduce it down to one chained conditional expression:



          bool is_less_than(struct version a, struct version b) {
          return a.major != b.major ? a.major < b.major :
          a.minor != b.minor ? a.minor < b.minor :
          a.patch != b.patch ? a.patch < b.patch :
          a.build < b.build;
          }


          I'd go further and recommend using unsigned short instead of unsigned char for the fields. Using unsigned char for numeric values is awkward, since you would have to cast them when using printf(). On a 64-bit architecture, a struct with four 2-byte fields would occupy 64 bits, so you wouldn't be saving anything by using unsigned char instead of unsigned short.






          share|improve this answer









          $endgroup$














            Your Answer






            StackExchange.ifUsing("editor", function () {
            StackExchange.using("externalEditor", function () {
            StackExchange.using("snippets", function () {
            StackExchange.snippets.init();
            });
            });
            }, "code-snippets");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "196"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: false,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: null,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217587%2fcompare-a-given-version-number-in-the-form-major-minor-build-patch-and-see-if-on%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            3 Answers
            3






            active

            oldest

            votes








            3 Answers
            3






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            2












            $begingroup$

            Yes, there is a cleaner way:



            if (a.major != b.major) {
            *result = a.major < b.major;
            } else if (a.minor != b.minor) {
            *result = a.minor < b.minor;
            } else if (a.patch != b.patch) {
            *result = a.patch < b.patch;
            } else {
            *result = a.build < b.build;
            }
            return OKAY;


            I reordered patch to come before build since that's how it is usually done. If your version scheme is different from this, good luck.



            Instead of unsigned char I would choose unsigned int so that your code can handle versions like 1.0.20190415.






            share|improve this answer











            $endgroup$













            • $begingroup$
              Nice catch on the patch, build ordering.
              $endgroup$
              – Costantino Grana
              1 hour ago
















            2












            $begingroup$

            Yes, there is a cleaner way:



            if (a.major != b.major) {
            *result = a.major < b.major;
            } else if (a.minor != b.minor) {
            *result = a.minor < b.minor;
            } else if (a.patch != b.patch) {
            *result = a.patch < b.patch;
            } else {
            *result = a.build < b.build;
            }
            return OKAY;


            I reordered patch to come before build since that's how it is usually done. If your version scheme is different from this, good luck.



            Instead of unsigned char I would choose unsigned int so that your code can handle versions like 1.0.20190415.






            share|improve this answer











            $endgroup$













            • $begingroup$
              Nice catch on the patch, build ordering.
              $endgroup$
              – Costantino Grana
              1 hour ago














            2












            2








            2





            $begingroup$

            Yes, there is a cleaner way:



            if (a.major != b.major) {
            *result = a.major < b.major;
            } else if (a.minor != b.minor) {
            *result = a.minor < b.minor;
            } else if (a.patch != b.patch) {
            *result = a.patch < b.patch;
            } else {
            *result = a.build < b.build;
            }
            return OKAY;


            I reordered patch to come before build since that's how it is usually done. If your version scheme is different from this, good luck.



            Instead of unsigned char I would choose unsigned int so that your code can handle versions like 1.0.20190415.






            share|improve this answer











            $endgroup$



            Yes, there is a cleaner way:



            if (a.major != b.major) {
            *result = a.major < b.major;
            } else if (a.minor != b.minor) {
            *result = a.minor < b.minor;
            } else if (a.patch != b.patch) {
            *result = a.patch < b.patch;
            } else {
            *result = a.build < b.build;
            }
            return OKAY;


            I reordered patch to come before build since that's how it is usually done. If your version scheme is different from this, good luck.



            Instead of unsigned char I would choose unsigned int so that your code can handle versions like 1.0.20190415.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 1 hour ago

























            answered 1 hour ago









            Roland IlligRoland Illig

            11.6k11946




            11.6k11946












            • $begingroup$
              Nice catch on the patch, build ordering.
              $endgroup$
              – Costantino Grana
              1 hour ago


















            • $begingroup$
              Nice catch on the patch, build ordering.
              $endgroup$
              – Costantino Grana
              1 hour ago
















            $begingroup$
            Nice catch on the patch, build ordering.
            $endgroup$
            – Costantino Grana
            1 hour ago




            $begingroup$
            Nice catch on the patch, build ordering.
            $endgroup$
            – Costantino Grana
            1 hour ago













            0












            $begingroup$

            Return status



            You create this:



            typedef int STATUS;
            #define ERROR -1
            #define OKAY 0


            which is basically a boolean status. Personally, I'd return a straight bool.



            Bug/Not what you mean



            Doing a



            result = NULL;


            is changing the local variable (parameter) result. It's not setting the result to NULL. In fact the caller won't probably have a pointer at all, but just a bool, which cannot properly be NULL.



            Shorter version



            I'm not sure this is cleaner, but here I go:



            bool is_less_than(struct version * original, struct version *compared, bool *result)
            {
            if(original == NULL || compared == NULL || result == NULL)
            return false;

            *result = original->major < compared->major || original->major == compared->major && (
            original->minor < compared->minor || original->minor == compared->minor && (
            original->build < compared->build || original->build == compared->build && (
            original->patch < compared->patch)));

            return true;
            }


            Next time, add a driver/test suite to your question, to ease the life of people answering. This can be one:



            int main(void) 
            {
            struct version ref = { 1, 2, 21, 8 };
            struct version lower1 = { 0, 2, 21, 8 };
            struct version lower2 = { 1, 1, 21, 8 };
            struct version lower3 = { 1, 2, 20, 8 };
            struct version lower4 = { 1, 2, 21, 7 };
            struct version equal = { 1, 2, 21, 8 };
            struct version higher1 = { 2, 2, 21, 8 };
            struct version higher2 = { 1, 3, 21, 8 };
            struct version higher3 = { 1, 2, 22, 8 };
            struct version higher4 = { 1, 2, 21, 9 };

            #define TEST(a,b,expect1,expect2)
            do {
            bool result1, result2;
            is_less_than((a), (b), &result1);
            is_less_than((b), (a), &result2);
            puts(result1==(expect1) && result2==(expect2)?"ok":"failed");
            } while(0)
            #define TESTL(a,b) TEST(a,b,true,false)
            #define TESTE(a,b) TEST(a,b,false,false)
            #define TESTH(a,b) TEST(a,b,false,true)

            TESTL(&lower1, &ref);
            TESTL(&lower2, &ref);
            TESTL(&lower3, &ref);
            TESTL(&lower4, &ref);
            TESTE(&equal, &ref);
            TESTH(&higher1, &ref);
            TESTH(&higher2, &ref);
            TESTH(&higher3, &ref);
            TESTH(&higher4, &ref);

            return 0;
            }





            share|improve this answer











            $endgroup$









            • 1




              $begingroup$
              As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
              $endgroup$
              – Roland Illig
              1 hour ago












            • $begingroup$
              @RolandIllig Updated. Thank you for the suggestion.
              $endgroup$
              – Costantino Grana
              1 hour ago
















            0












            $begingroup$

            Return status



            You create this:



            typedef int STATUS;
            #define ERROR -1
            #define OKAY 0


            which is basically a boolean status. Personally, I'd return a straight bool.



            Bug/Not what you mean



            Doing a



            result = NULL;


            is changing the local variable (parameter) result. It's not setting the result to NULL. In fact the caller won't probably have a pointer at all, but just a bool, which cannot properly be NULL.



            Shorter version



            I'm not sure this is cleaner, but here I go:



            bool is_less_than(struct version * original, struct version *compared, bool *result)
            {
            if(original == NULL || compared == NULL || result == NULL)
            return false;

            *result = original->major < compared->major || original->major == compared->major && (
            original->minor < compared->minor || original->minor == compared->minor && (
            original->build < compared->build || original->build == compared->build && (
            original->patch < compared->patch)));

            return true;
            }


            Next time, add a driver/test suite to your question, to ease the life of people answering. This can be one:



            int main(void) 
            {
            struct version ref = { 1, 2, 21, 8 };
            struct version lower1 = { 0, 2, 21, 8 };
            struct version lower2 = { 1, 1, 21, 8 };
            struct version lower3 = { 1, 2, 20, 8 };
            struct version lower4 = { 1, 2, 21, 7 };
            struct version equal = { 1, 2, 21, 8 };
            struct version higher1 = { 2, 2, 21, 8 };
            struct version higher2 = { 1, 3, 21, 8 };
            struct version higher3 = { 1, 2, 22, 8 };
            struct version higher4 = { 1, 2, 21, 9 };

            #define TEST(a,b,expect1,expect2)
            do {
            bool result1, result2;
            is_less_than((a), (b), &result1);
            is_less_than((b), (a), &result2);
            puts(result1==(expect1) && result2==(expect2)?"ok":"failed");
            } while(0)
            #define TESTL(a,b) TEST(a,b,true,false)
            #define TESTE(a,b) TEST(a,b,false,false)
            #define TESTH(a,b) TEST(a,b,false,true)

            TESTL(&lower1, &ref);
            TESTL(&lower2, &ref);
            TESTL(&lower3, &ref);
            TESTL(&lower4, &ref);
            TESTE(&equal, &ref);
            TESTH(&higher1, &ref);
            TESTH(&higher2, &ref);
            TESTH(&higher3, &ref);
            TESTH(&higher4, &ref);

            return 0;
            }





            share|improve this answer











            $endgroup$









            • 1




              $begingroup$
              As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
              $endgroup$
              – Roland Illig
              1 hour ago












            • $begingroup$
              @RolandIllig Updated. Thank you for the suggestion.
              $endgroup$
              – Costantino Grana
              1 hour ago














            0












            0








            0





            $begingroup$

            Return status



            You create this:



            typedef int STATUS;
            #define ERROR -1
            #define OKAY 0


            which is basically a boolean status. Personally, I'd return a straight bool.



            Bug/Not what you mean



            Doing a



            result = NULL;


            is changing the local variable (parameter) result. It's not setting the result to NULL. In fact the caller won't probably have a pointer at all, but just a bool, which cannot properly be NULL.



            Shorter version



            I'm not sure this is cleaner, but here I go:



            bool is_less_than(struct version * original, struct version *compared, bool *result)
            {
            if(original == NULL || compared == NULL || result == NULL)
            return false;

            *result = original->major < compared->major || original->major == compared->major && (
            original->minor < compared->minor || original->minor == compared->minor && (
            original->build < compared->build || original->build == compared->build && (
            original->patch < compared->patch)));

            return true;
            }


            Next time, add a driver/test suite to your question, to ease the life of people answering. This can be one:



            int main(void) 
            {
            struct version ref = { 1, 2, 21, 8 };
            struct version lower1 = { 0, 2, 21, 8 };
            struct version lower2 = { 1, 1, 21, 8 };
            struct version lower3 = { 1, 2, 20, 8 };
            struct version lower4 = { 1, 2, 21, 7 };
            struct version equal = { 1, 2, 21, 8 };
            struct version higher1 = { 2, 2, 21, 8 };
            struct version higher2 = { 1, 3, 21, 8 };
            struct version higher3 = { 1, 2, 22, 8 };
            struct version higher4 = { 1, 2, 21, 9 };

            #define TEST(a,b,expect1,expect2)
            do {
            bool result1, result2;
            is_less_than((a), (b), &result1);
            is_less_than((b), (a), &result2);
            puts(result1==(expect1) && result2==(expect2)?"ok":"failed");
            } while(0)
            #define TESTL(a,b) TEST(a,b,true,false)
            #define TESTE(a,b) TEST(a,b,false,false)
            #define TESTH(a,b) TEST(a,b,false,true)

            TESTL(&lower1, &ref);
            TESTL(&lower2, &ref);
            TESTL(&lower3, &ref);
            TESTL(&lower4, &ref);
            TESTE(&equal, &ref);
            TESTH(&higher1, &ref);
            TESTH(&higher2, &ref);
            TESTH(&higher3, &ref);
            TESTH(&higher4, &ref);

            return 0;
            }





            share|improve this answer











            $endgroup$



            Return status



            You create this:



            typedef int STATUS;
            #define ERROR -1
            #define OKAY 0


            which is basically a boolean status. Personally, I'd return a straight bool.



            Bug/Not what you mean



            Doing a



            result = NULL;


            is changing the local variable (parameter) result. It's not setting the result to NULL. In fact the caller won't probably have a pointer at all, but just a bool, which cannot properly be NULL.



            Shorter version



            I'm not sure this is cleaner, but here I go:



            bool is_less_than(struct version * original, struct version *compared, bool *result)
            {
            if(original == NULL || compared == NULL || result == NULL)
            return false;

            *result = original->major < compared->major || original->major == compared->major && (
            original->minor < compared->minor || original->minor == compared->minor && (
            original->build < compared->build || original->build == compared->build && (
            original->patch < compared->patch)));

            return true;
            }


            Next time, add a driver/test suite to your question, to ease the life of people answering. This can be one:



            int main(void) 
            {
            struct version ref = { 1, 2, 21, 8 };
            struct version lower1 = { 0, 2, 21, 8 };
            struct version lower2 = { 1, 1, 21, 8 };
            struct version lower3 = { 1, 2, 20, 8 };
            struct version lower4 = { 1, 2, 21, 7 };
            struct version equal = { 1, 2, 21, 8 };
            struct version higher1 = { 2, 2, 21, 8 };
            struct version higher2 = { 1, 3, 21, 8 };
            struct version higher3 = { 1, 2, 22, 8 };
            struct version higher4 = { 1, 2, 21, 9 };

            #define TEST(a,b,expect1,expect2)
            do {
            bool result1, result2;
            is_less_than((a), (b), &result1);
            is_less_than((b), (a), &result2);
            puts(result1==(expect1) && result2==(expect2)?"ok":"failed");
            } while(0)
            #define TESTL(a,b) TEST(a,b,true,false)
            #define TESTE(a,b) TEST(a,b,false,false)
            #define TESTH(a,b) TEST(a,b,false,true)

            TESTL(&lower1, &ref);
            TESTL(&lower2, &ref);
            TESTL(&lower3, &ref);
            TESTL(&lower4, &ref);
            TESTE(&equal, &ref);
            TESTH(&higher1, &ref);
            TESTH(&higher2, &ref);
            TESTH(&higher3, &ref);
            TESTH(&higher4, &ref);

            return 0;
            }






            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 1 hour ago

























            answered 1 hour ago









            Costantino GranaCostantino Grana

            18728




            18728








            • 1




              $begingroup$
              As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
              $endgroup$
              – Roland Illig
              1 hour ago












            • $begingroup$
              @RolandIllig Updated. Thank you for the suggestion.
              $endgroup$
              – Costantino Grana
              1 hour ago














            • 1




              $begingroup$
              As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
              $endgroup$
              – Roland Illig
              1 hour ago












            • $begingroup$
              @RolandIllig Updated. Thank you for the suggestion.
              $endgroup$
              – Costantino Grana
              1 hour ago








            1




            1




            $begingroup$
            As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
            $endgroup$
            – Roland Illig
            1 hour ago






            $begingroup$
            As for every comparator function, the driver/test should compare each pair of example data to at least ensure that the ordering is transitive and that less(x, x) is never true.
            $endgroup$
            – Roland Illig
            1 hour ago














            $begingroup$
            @RolandIllig Updated. Thank you for the suggestion.
            $endgroup$
            – Costantino Grana
            1 hour ago




            $begingroup$
            @RolandIllig Updated. Thank you for the suggestion.
            $endgroup$
            – Costantino Grana
            1 hour ago











            0












            $begingroup$

            I don't see any advantage to having the function to take three pointers (two for input and one for output) and return a status code. As a result of that unnecessarily error-prone design, the function has to handle the possibility of null pointers, and the caller is expected to handle a status code. But why should such a simple comparison have these failure modes at all?



            The danger is further complicated by the fact that neither of the in-parameters is declared const.



            Just pass the two versions by value, and you would eliminate all of that complication! On any modern 32-bit or 64-bit processor, passing a four-byte struct by value should actually be more efficient than passing it by reference — especially since you don't have to dereference the pointers to access each field.



            With all of the potential errors out of the way, taking @RolandIllig's suggestion, you could then reduce it down to one chained conditional expression:



            bool is_less_than(struct version a, struct version b) {
            return a.major != b.major ? a.major < b.major :
            a.minor != b.minor ? a.minor < b.minor :
            a.patch != b.patch ? a.patch < b.patch :
            a.build < b.build;
            }


            I'd go further and recommend using unsigned short instead of unsigned char for the fields. Using unsigned char for numeric values is awkward, since you would have to cast them when using printf(). On a 64-bit architecture, a struct with four 2-byte fields would occupy 64 bits, so you wouldn't be saving anything by using unsigned char instead of unsigned short.






            share|improve this answer









            $endgroup$


















              0












              $begingroup$

              I don't see any advantage to having the function to take three pointers (two for input and one for output) and return a status code. As a result of that unnecessarily error-prone design, the function has to handle the possibility of null pointers, and the caller is expected to handle a status code. But why should such a simple comparison have these failure modes at all?



              The danger is further complicated by the fact that neither of the in-parameters is declared const.



              Just pass the two versions by value, and you would eliminate all of that complication! On any modern 32-bit or 64-bit processor, passing a four-byte struct by value should actually be more efficient than passing it by reference — especially since you don't have to dereference the pointers to access each field.



              With all of the potential errors out of the way, taking @RolandIllig's suggestion, you could then reduce it down to one chained conditional expression:



              bool is_less_than(struct version a, struct version b) {
              return a.major != b.major ? a.major < b.major :
              a.minor != b.minor ? a.minor < b.minor :
              a.patch != b.patch ? a.patch < b.patch :
              a.build < b.build;
              }


              I'd go further and recommend using unsigned short instead of unsigned char for the fields. Using unsigned char for numeric values is awkward, since you would have to cast them when using printf(). On a 64-bit architecture, a struct with four 2-byte fields would occupy 64 bits, so you wouldn't be saving anything by using unsigned char instead of unsigned short.






              share|improve this answer









              $endgroup$
















                0












                0








                0





                $begingroup$

                I don't see any advantage to having the function to take three pointers (two for input and one for output) and return a status code. As a result of that unnecessarily error-prone design, the function has to handle the possibility of null pointers, and the caller is expected to handle a status code. But why should such a simple comparison have these failure modes at all?



                The danger is further complicated by the fact that neither of the in-parameters is declared const.



                Just pass the two versions by value, and you would eliminate all of that complication! On any modern 32-bit or 64-bit processor, passing a four-byte struct by value should actually be more efficient than passing it by reference — especially since you don't have to dereference the pointers to access each field.



                With all of the potential errors out of the way, taking @RolandIllig's suggestion, you could then reduce it down to one chained conditional expression:



                bool is_less_than(struct version a, struct version b) {
                return a.major != b.major ? a.major < b.major :
                a.minor != b.minor ? a.minor < b.minor :
                a.patch != b.patch ? a.patch < b.patch :
                a.build < b.build;
                }


                I'd go further and recommend using unsigned short instead of unsigned char for the fields. Using unsigned char for numeric values is awkward, since you would have to cast them when using printf(). On a 64-bit architecture, a struct with four 2-byte fields would occupy 64 bits, so you wouldn't be saving anything by using unsigned char instead of unsigned short.






                share|improve this answer









                $endgroup$



                I don't see any advantage to having the function to take three pointers (two for input and one for output) and return a status code. As a result of that unnecessarily error-prone design, the function has to handle the possibility of null pointers, and the caller is expected to handle a status code. But why should such a simple comparison have these failure modes at all?



                The danger is further complicated by the fact that neither of the in-parameters is declared const.



                Just pass the two versions by value, and you would eliminate all of that complication! On any modern 32-bit or 64-bit processor, passing a four-byte struct by value should actually be more efficient than passing it by reference — especially since you don't have to dereference the pointers to access each field.



                With all of the potential errors out of the way, taking @RolandIllig's suggestion, you could then reduce it down to one chained conditional expression:



                bool is_less_than(struct version a, struct version b) {
                return a.major != b.major ? a.major < b.major :
                a.minor != b.minor ? a.minor < b.minor :
                a.patch != b.patch ? a.patch < b.patch :
                a.build < b.build;
                }


                I'd go further and recommend using unsigned short instead of unsigned char for the fields. Using unsigned char for numeric values is awkward, since you would have to cast them when using printf(). On a 64-bit architecture, a struct with four 2-byte fields would occupy 64 bits, so you wouldn't be saving anything by using unsigned char instead of unsigned short.







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered 34 mins ago









                200_success200_success

                131k17157422




                131k17157422






























                    draft saved

                    draft discarded




















































                    Thanks for contributing an answer to Code Review Stack Exchange!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    Use MathJax to format equations. MathJax reference.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217587%2fcompare-a-given-version-number-in-the-form-major-minor-build-patch-and-see-if-on%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    Popular posts from this blog

                    How to label and detect the document text images

                    Vallis Paradisi

                    Tabula Rosettana