Is the checksum being computed according to the requirement ?

Discussion in 'C Programming' started by John, Jan 31, 2011.

  1. John

    John Guest

    This is not a homework problem.

    So the problem requires me to compute a checksum in a signed char variable that is initialized to -1. As each character is read from standard input, it is added to the checksum. Any overflow from the checksum variable is ignored. When all of the characters have been written, the checksum is then written as a decimal integer, which may be negative. Follow checksum with a new-line.

    For example,
    Hello world!
    102

    Here is the code


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

    int main(){

    int ch;
    int at_beginning = 1;
    int line = 0;
    signed char checksum = -1;

    while( (ch=getchar())!= EOF){

    if(at_beginning == 1){

    at_beginning = 0;
    line+=1;
    printf("%d Output: ", line);

    }

    checksum = checksum + ch;
    putchar(ch);

    if(ch == '\n'){
    at_beginning = 1;
    printf("Checksum: %d\n", checksum);
    checksum = -1;
    }
    }

    return EXIT_SUCCESS;
    }
     
    John, Jan 31, 2011
    #1
    1. Advertising

  2. John

    Ian Collins Guest

    On 01/31/11 02:50 PM, John wrote:
    > This is not a homework problem.
    >
    > So the problem requires me to compute a checksum in a signed char variable that is initialized to -1. As each character is read from standard input, it is added to the checksum. Any overflow from the checksum variable is ignored. When all of the characters have been written, the checksum is then written as a decimal integer, which may be negative. Follow checksum with a new-line.
    >
    > For example,
    > Hello world!
    > 102


    Why don't you write some test cases?

    --
    Ian Collins
     
    Ian Collins, Jan 31, 2011
    #2
    1. Advertising

  3. John

    Thad Smith Guest

    On 1/30/2011 6:50 PM, John wrote:
    > This is not a homework problem.
    >
    > So the problem requires me to compute a checksum in a signed char variable that is initialized to -1. As each character is read from standard input, it is added to the checksum. Any overflow from the checksum variable is ignored. When all of the characters have been written, the checksum is then written as a decimal integer, which may be negative. Follow checksum with a new-line.


    Since an overflow of a signed integer type results in behavior and possible
    value not defined by C, you need to replace "ignore overflow" with si\omething
    specific.

    --
    Thad
     
    Thad Smith, Feb 4, 2011
    #3
  4. John

    Shao Miller Guest

    John wrote:
    > This is not a homework problem.
    >
    > So the problem requires me to compute a checksum in a signed char variable that is initialized to -1. As each character is read...it is added to the checksum. Any overflow from the checksum variable is ignored.


    I think that an addition expression involving 'signed char' can overflow
    if the addition exceeds 'SCHAR_MAX'. I'm not sure about a standard way
    to tell the compiler "ignore overflow for a 'signed char' addition."

    If you are using getchar(), I think that's like using getc(stdin), which
    I think is fairly similar to using fgetc(stdin). Since fgetc() gets an
    'unsigned char' and then converts it to an 'int' and returns that,
    perhaps the problem you are dealing with actually includes:

    "Compute a checksum using an 'unsigned char' object where that object is
    initialized to all-bits-set (all one bits for the value bits), which
    happens to be the two's complement representation for -1."

    I think that an addition expression involving 'unsigned char' cannot
    overflow, so your "ignored" criteria would be satisifed by using that
    type, instead.

    >
    > For example,
    > Hello world!
    > 102
    >
    > Here is the code
    >
    >
    > #include<stdio.h>
    > #include<stdlib.h>
    >
    > int main(){


    Or maybe:

    int main(void)

    >
    > int ch;
    > int at_beginning = 1;
    > int line = 0;
    > signed char checksum = -1;
    >
    > while( (ch=getchar())!= EOF){
    >
    > if(at_beginning == 1){
    >
    > at_beginning = 0;
    > line+=1;
    > printf("%d Output: ", line);
    >
    > }
    >
    > checksum = checksum + ch;


    The above could overflow, I think. Perhaps if you'd instead declared:

    unsigned char ch;
    unsigned char checksum = UCHAR_MAX;

    Then that might work for you, as 'checksum' would be all-bits-set (well,
    value bits), and further assuming that the problem really wants that
    when the problem statement includes mention of "-1".

    Hope this helps! :)
     
    Shao Miller, May 8, 2011
    #4
  5. John

    Shao Miller Guest

    On 5/8/2011 11:26 PM, pete wrote:
    > Shao Miller wrote:
    >
    >> I think that an addition expression involving 'unsigned char' cannot
    >> overflow, so your "ignored" criteria would be satisifed by using that
    >> type, instead.

    >
    > I've never heard of a case where INT_MAX equals UCHAR_MAX,
    > but it is allowed,
    > and if INT_MAX does equal UCHAR_MAX,
    > then (UCHAR_MAX + 1) is undefined.
    >


    Yikes; oh no! :) That'd be at least CHAR_BIT - 1 bits of padding for an
    'int'!

    What about:

    checksum = (unsigned long int)checksum + (unsigned long int)ch;

    ? Would that be portable in a standard sense?

    Thanks. :)
     
    Shao Miller, May 8, 2011
    #5
  6. Shao Miller <> writes:

    > John wrote:
    >> This is not a homework problem.
    >>
    >> So the problem requires me to compute a checksum in a signed char variable that is initialized to -1. As each character is read...it is added to the checksum. Any overflow from the checksum variable is ignored.

    >
    > I think that an addition expression involving 'signed char' can
    > overflow if the addition exceeds 'SCHAR_MAX'. I'm not sure about a
    > standard way to tell the compiler "ignore overflow for a 'signed char'
    > addition."


    That's not quite correct -- at least it glosses of over some important
    details. Technically, an addition expression involving signed char
    can't overflow because it can't happen -- the operands will be promoted
    in to int. Of course, in the slightly odd (but not at all unheard of)
    situation where char and int are the same size, the effect is as you
    describe, only using INT_MAX rather than SCHAR_MAX.

    However, in the much more common situation where char is much smaller
    than int, the addition can not overflow. What goes wrong is the
    conversion of the result back to signed char. This is not undefined
    behaviour even when the value is too large. It's very close to UB
    (from a portability point of vew) but it is implementation defined.

    > If you are using getchar(), I think that's like using getc(stdin),
    > which I think is fairly similar to using fgetc(stdin). Since fgetc()
    > gets an 'unsigned char' and then converts it to an 'int' and returns
    > that, perhaps the problem you are dealing with actually includes:
    >
    > "Compute a checksum using an 'unsigned char' object where that object
    > is initialized to all-bits-set (all one bits for the value bits),
    > which happens to be the two's complement representation for -1."
    >
    > I think that an addition expression involving 'unsigned char' cannot
    > overflow, so your "ignored" criteria would be satisifed by using that
    > type, instead.


    Yes, but only for the technical reason that the operands will promote,
    so there is no actual addition using unsigned char. unsigned char will
    most often promote to int, and this can overflow in some outlandish
    cases (imagine 16 bit ints and 15 bit chars). The most portable
    solution is to convert (with a cast) the unsigned chars to unsigned int.
    The arithmetic then won't overflow (let's ignore the terrible corner
    case where unsigned int promotes to int!) and the conversion back to
    unsigned char is well-defined.

    <snip>
    --
    Ben.
     
    Ben Bacarisse, May 9, 2011
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Raymond Du

    Computed columns in datagrid

    Raymond Du, Dec 1, 2004, in forum: ASP .Net
    Replies:
    3
    Views:
    2,605
    Joe Fallon
    Dec 2, 2004
  2. John Dalberg
    Replies:
    1
    Views:
    434
    Bruce Barker
    Feb 3, 2006
  3. Replies:
    2
    Views:
    889
    Adam Maass
    May 24, 2005
  4. Pascal Steiss
    Replies:
    1
    Views:
    3,458
    Toby Inkster
    Mar 19, 2005
  5. Christian Roth
    Replies:
    2
    Views:
    420
    Dimitre Novatchev
    Dec 16, 2003
Loading...

Share This Page