How can i emulate sizeof()

Discussion in 'C Programming' started by Eugeny Myunster, Apr 30, 2008.

  1. Hello all,
    How can i emulate sizeof()
    only for integers?
    Eugeny Myunster, Apr 30, 2008
    #1
    1. Advertising

  2. Eugeny Myunster wrote:
    >
    > Hello all,
    > How can i emulate sizeof()
    > only for integers?


    I'd really love to know which instructors keep giving this assignment.

    Why do you want to "emulate sizeof", when sizeof exists just for this
    purpose?

    How about:

    #define MySizeof(x) sizeof(x)

    Now you can "emulate sizeof" by using "MySizeof(int)", for example.

    --
    +-------------------------+--------------------+-----------------------+
    | Kenneth J. Brody | www.hvcomputer.com | #include |
    | kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h> |
    +-------------------------+--------------------+-----------------------+
    Don't e-mail me at: <mailto:>
    Kenneth Brody, Apr 30, 2008
    #2
    1. Advertising

  3. Kenneth Brody <> writes:
    > Eugeny Myunster wrote:
    >>
    >> Hello all,
    >> How can i emulate sizeof()
    >> only for integers?

    >
    > I'd really love to know which instructors keep giving this assignment.
    >
    > Why do you want to "emulate sizeof", when sizeof exists just for this
    > purpose?
    >
    > How about:
    >
    > #define MySizeof(x) sizeof(x)
    >
    > Now you can "emulate sizeof" by using "MySizeof(int)", for example.


    Except that the macro, unlike the sizeof operator, requires a
    parenthesized argument; you can't write "MySizeof 42".

    I'd use:

    #define MySizeof sizeof

    which is equally useful (i.e., not at all).

    A serious answer to the original poster: Why do you want to do this?
    There are ways to determine the size of an object without using the
    sizeof operator, but there's no point in using them; the sizeof
    operator exists for exactly this purpose.

    Q: How do I pound in a nail? I don't want to use a hammer.
    A: Use a hammer anyway; that's what it's for.

    Having said that, it's not entirely pointless *as an exercise*.
    Figuring out how to compute the size of something without using sizeof
    does present an opportunity to demonstrate that you understand certain
    aspects of the language. The resulting piece of code isn't going to
    be useful in itself, but then neither is the classic "hello, world"
    program; if I really want to print "hello, world" on stdout, I'll use
    echo. (There's a GNU "hello" program, for example, but it exists
    purely as a demo; it's not actually useful.) That's just the nature
    of homework assignments.

    Oh, and speaking of homework assignments: DO IT YOURSELF. What will
    you learn if we just give you the answer? We're willing to offer
    hints if you try to do it yourself, but if you want us to solve the
    problem for you, please give us your instructor's e-mail address so we
    can submit our solutions directly.

    --
    Keith Thompson (The_Other_Keith) <>
    Nokia
    "We must do something. This is something. Therefore, we must do this."
    -- Antony Jay and Jonathan Lynn, "Yes Minister"
    Keith Thompson, Apr 30, 2008
    #3
  4. Eugeny Myunster

    user923005 Guest

    On Apr 30, 9:56 am, Eugeny Myunster <> wrote:
    > Hello all,
    >         How can i emulate sizeof()
    >         only for integers?


    Of course, it is lunacy to use something else when you want a size,
    since the sizeof operator is perfect for that task.

    That having been said, you can make an array of 2 objects, and get an
    unsigned char pointer to the first and second object and subtract the
    pointer difference to find the size.

    E.g.

    #define StupidEvilTwistedSizeof(type,ans) { \
    type a[2]; \
    unsigned char *start = (unsigned char *)&a[0]; \
    unsigned char *end = (unsigned char *)&a[1]; \
    *ans=end-start;}

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

    typedef struct thingy {
    int a;
    char b;
    long c;
    } thingy;

    int main(void)
    {
    size_t size;
    size_t *psize = &size;
    StupidEvilTwistedSizeof(char, psize);
    printf("I am ashamed to say that the size of char is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(short, psize);
    printf("I am ashamed to say that the size of short is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long, psize);
    printf("I am ashamed to say that the size of long is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long long, psize);
    printf("I am ashamed to say that the size of long long is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(float, psize);
    printf("I am ashamed to say that the size of float is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(double, psize);
    printf("I am ashamed to say that the size of double is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long double, psize);
    printf("I am ashamed to say that the size of long double is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(thingy, psize);
    printf("I am ashamed to say that the size of thingy is %u\n",
    (unsigned) size);

    return 0;
    }
    /*
    Possible output:
    I am ashamed to say that the size of char is 1
    I am ashamed to say that the size of short is 2
    I am ashamed to say that the size of long is 4
    I am ashamed to say that the size of long long is 8
    I am ashamed to say that the size of float is 4
    I am ashamed to say that the size of double is 8
    I am ashamed to say that the size of long double is 8
    I am ashamed to say that the size of thingy is 12
    */
    user923005, Apr 30, 2008
    #4
  5. Eugeny Myunster

    user923005 Guest

    On Apr 30, 3:06 pm, user923005 <> wrote:
    > On Apr 30, 9:56 am, Eugeny Myunster <> wrote:
    >
    > > Hello all,
    > >         How can i emulate sizeof()
    > >         only for integers?

    >
    > Of course, it is lunacy to use something else when you want a size,
    > since the sizeof operator is perfect for that task.
    >
    > That having been said, you can make an array of 2 objects, and get an
    > unsigned char pointer to the first and second object and subtract the
    > pointer difference to find the size.
    >
    > E.g.
    >
    > #define StupidEvilTwistedSizeof(type,ans) { \
    > type a[2]; \
    > unsigned char *start = (unsigned char *)&a[0]; \
    > unsigned char *end = (unsigned char *)&a[1]; \
    > *ans=end-start;}
    >
    > #include <stdio.h>
    > #include <stdlib.h>
    >
    > typedef struct thingy {
    >     int             a;
    >     char            b;
    >     long            c;
    >
    > }   thingy;
    >
    > int             main(void)
    > {
    >     size_t          size;
    >     size_t         *psize = &size;
    >     StupidEvilTwistedSizeof(char, psize);
    >     printf("I am ashamed to say that the size of char is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(short, psize);
    >     printf("I am ashamed to say that the size of short is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long, psize);
    >     printf("I am ashamed to say that the size of long is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long long, psize);
    >     printf("I am ashamed to say that the size of long long is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(float, psize);
    >     printf("I am ashamed to say that the size of float is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(double, psize);
    >     printf("I am ashamed to say that the size of double is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long double, psize);
    >     printf("I am ashamed to say that the size of long double is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(thingy, psize);
    >     printf("I am ashamed to say that the size of thingy is %u\n",
    > (unsigned) size);
    >
    >     return 0;}
    >
    > /*
    > Possible output:
    > I am ashamed to say that the size of char is 1
    > I am ashamed to say that the size of short is 2
    > I am ashamed to say that the size of long is 4
    > I am ashamed to say that the size of long long is 8
    > I am ashamed to say that the size of float is 4
    > I am ashamed to say that the size of double is 8
    > I am ashamed to say that the size of long double is 8
    > I am ashamed to say that the size of thingy is 12
    > */


    Updated version:

    #define StupidEvilTwistedSizeof(type,ans) { \
    type a[2]; \
    unsigned char *start = (unsigned char *)&a[0]; \
    unsigned char *end = (unsigned char *)&a[1]; \
    *ans=end-start;}

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

    typedef struct thingy {
    int a;
    char b;
    long c;
    } thingy;

    typedef double (*PFI) ( double );

    int main(void)
    {
    size_t size;
    size_t *psize = &size;
    StupidEvilTwistedSizeof(char, psize);
    printf("I am ashamed to say that the size of char is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(short, psize);
    printf("I am ashamed to say that the size of short is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long, psize);
    printf("I am ashamed to say that the size of long is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long long, psize);
    printf("I am ashamed to say that the size of long long is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(float, psize);
    printf("I am ashamed to say that the size of float is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(double, psize);
    printf("I am ashamed to say that the size of double is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long double, psize);
    printf("I am ashamed to say that the size of long double is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(thingy, psize);
    printf("I am ashamed to say that the size of thingy is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(char *, psize);
    printf("I am ashamed to say that the size of char * is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(int *, psize);
    printf("I am ashamed to say that the size of int * is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(long *, psize);
    printf("I am ashamed to say that the size of long * is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(void *, psize);
    printf("I am ashamed to say that the size of void * is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(PFI, psize);
    printf("I am ashamed to say that the size of PFI is %u\n",
    (unsigned) size);
    StupidEvilTwistedSizeof(void **, psize);
    printf("I am ashamed to say that the size of void ** is %u\n",
    (unsigned) size);

    return 0;
    }
    /*
    Possible output:
    I am ashamed to say that the size of char is 1
    I am ashamed to say that the size of short is 2
    I am ashamed to say that the size of long is 4
    I am ashamed to say that the size of long long is 8
    I am ashamed to say that the size of float is 4
    I am ashamed to say that the size of double is 8
    I am ashamed to say that the size of long double is 8
    I am ashamed to say that the size of thingy is 12
    I am ashamed to say that the size of char * is 4
    I am ashamed to say that the size of int * is 4
    I am ashamed to say that the size of long * is 4
    I am ashamed to say that the size of void * is 4
    I am ashamed to say that the size of PFI is 4
    I am ashamed to say that the size of void ** is 4
    */
    user923005, Apr 30, 2008
    #5
  6. Eugeny Myunster

    user923005 Guest

    On Apr 30, 3:23 pm, user923005 <> wrote:
    > On Apr 30, 3:06 pm, user923005 <> wrote:
    >
    >
    >
    >
    >
    > > On Apr 30, 9:56 am, Eugeny Myunster <> wrote:

    >
    > > > Hello all,
    > > >         How can i emulate sizeof()
    > > >         only for integers?

    >
    > > Of course, it is lunacy to use something else when you want a size,
    > > since the sizeof operator is perfect for that task.

    >
    > > That having been said, you can make an array of 2 objects, and get an
    > > unsigned char pointer to the first and second object and subtract the
    > > pointer difference to find the size.

    >
    > > E.g.

    >
    > > #define StupidEvilTwistedSizeof(type,ans) { \
    > > type a[2]; \
    > > unsigned char *start = (unsigned char *)&a[0]; \
    > > unsigned char *end = (unsigned char *)&a[1]; \
    > > *ans=end-start;}

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

    >
    > > typedef struct thingy {
    > >     int             a;
    > >     char            b;
    > >     long            c;

    >
    > > }   thingy;

    >
    > > int             main(void)
    > > {
    > >     size_t          size;
    > >     size_t         *psize = &size;
    > >     StupidEvilTwistedSizeof(char, psize);
    > >     printf("I am ashamed to say that the size of char is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(short, psize);
    > >     printf("I am ashamed to say that the size of short is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(long, psize);
    > >     printf("I am ashamed to say that the size of long is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(long long, psize);
    > >     printf("I am ashamed to say that the size of long long is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(float, psize);
    > >     printf("I am ashamed to say that the size of float is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(double, psize);
    > >     printf("I am ashamed to say that the size of double is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(long double, psize);
    > >     printf("I am ashamed to say that the size of long double is %u\n",
    > > (unsigned) size);
    > >     StupidEvilTwistedSizeof(thingy, psize);
    > >     printf("I am ashamed to say that the size of thingy is %u\n",
    > > (unsigned) size);

    >
    > >     return 0;}

    >
    > > /*
    > > Possible output:
    > > I am ashamed to say that the size of char is 1
    > > I am ashamed to say that the size of short is 2
    > > I am ashamed to say that the size of long is 4
    > > I am ashamed to say that the size of long long is 8
    > > I am ashamed to say that the size of float is 4
    > > I am ashamed to say that the size of double is 8
    > > I am ashamed to say that the size of long double is 8
    > > I am ashamed to say that the size of thingy is 12
    > > */

    >
    > Updated version:
    >
    > #define StupidEvilTwistedSizeof(type,ans) { \
    > type a[2]; \
    > unsigned char *start = (unsigned char *)&a[0]; \
    > unsigned char *end = (unsigned char *)&a[1]; \
    > *ans=end-start;}
    >
    > #include <stdio.h>
    > #include <stdlib.h>
    >
    > typedef struct thingy {
    >     int             a;
    >     char            b;
    >     long            c;
    >
    > }               thingy;
    >
    > typedef double (*PFI) ( double );
    >
    > int             main(void)
    > {
    >     size_t          size;
    >     size_t         *psize = &size;
    >     StupidEvilTwistedSizeof(char, psize);
    >     printf("I am ashamed to say that the size of char is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(short, psize);
    >     printf("I am ashamed to say that the size of short is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long, psize);
    >     printf("I am ashamed to say that the size of long is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long long, psize);
    >     printf("I am ashamed to say that the size of long long is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(float, psize);
    >     printf("I am ashamed to say that the size of float is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(double, psize);
    >     printf("I am ashamed to say that the size of double is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long double, psize);
    >     printf("I am ashamed to say that the size of long double is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(thingy, psize);
    >     printf("I am ashamed to say that the size of thingy is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(char *, psize);
    >     printf("I am ashamed to say that the size of char * is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(int *, psize);
    >     printf("I am ashamed to say that the size of int * is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(long *, psize);
    >     printf("I am ashamed to say that the size of long * is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(void *, psize);
    >     printf("I am ashamed to say that the size of void * is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(PFI, psize);
    >     printf("I am ashamed to say that the size of PFI is %u\n",
    > (unsigned) size);
    >     StupidEvilTwistedSizeof(void **, psize);
    >     printf("I am ashamed to say that the size of void ** is %u\n",
    > (unsigned) size);
    >
    >     return 0;}
    >
    > /*
    > Possible output:
    > I am ashamed to say that the size of char is 1
    > I am ashamed to say that the size of short is 2
    > I am ashamed to say that the size of long is 4
    > I am ashamed to say that the size of long long is 8
    > I am ashamed to say that the size of float is 4
    > I am ashamed to say that the size of double is 8
    > I am ashamed to say that the size of long double is 8
    > I am ashamed to say that the size of thingy is 12
    > I am ashamed to say that the size of char * is 4
    > I am ashamed to say that the size of int * is 4
    > I am ashamed to say that the size of long * is 4
    > I am ashamed to say that the size of void * is 4
    > I am ashamed to say that the size of PFI is 4
    > I am ashamed to say that the size of void ** is 4
    > */



    The biggest problem with this method is that it works ONLY on types
    and NOT on objects of a given type.
    The sizeof operator works nicely on both.
    user923005, Apr 30, 2008
    #6
  7. On Wed, 30 Apr 2008 15:06:16 -0700 (PDT), user923005
    <> wrote:

    > On Apr 30, 9:56 am, Eugeny Myunster <> wrote:
    > > Hello all,
    > >         How can i emulate sizeof()
    > >         only for integers?

    >
    > Of course, it is lunacy to use something else when you want a size,
    > since the sizeof operator is perfect for that task.
    >

    Concur.

    > That having been said, you can make an array of 2 objects, and get an
    > unsigned char pointer to the first and second object and subtract the
    > pointer difference to find the size.
    >

    You don't even need an array of two: just a single object,
    and use the address-one-past. You can't (safely, portably)
    _dereference_ that address, but you can compute it.

    And downthread
    > The biggest problem with this method is that it works ONLY on types
    > and NOT on objects of a given type.
    > The sizeof operator works nicely on both.


    Concur again. Although you can do a sizeof_type which creates and
    measures a dummy object, and a different sizeof_object which measures
    an existing object. But you still can't match the operator for sizeof
    a constant or other nonlvalue* expression such as the (hypothetical)
    return of a function or function pointer. (* Ignoring the C99 glitch
    that unintentionallly and crazily makes almost everything an lvalue.)

    - formerly david.thompson1 || achar(64) || worldnet.att.net
    David Thompson, May 12, 2008
    #7
  8. In article <>,
    David Thompson <> wrote:
    >On Wed, 30 Apr 2008 15:06:16 -0700 (PDT), user923005
    ><> wrote:
    >
    >> On Apr 30, 9:56 am, Eugeny Myunster <> wrote:
    >> > Hello all,
    >> >         How can i emulate sizeof()
    >> >         only for integers?

    >>
    >> Of course, it is lunacy to use something else when you want a size,
    >> since the sizeof operator is perfect for that task.


    It's not lunacy, if a woman tells you she'll sleep with you if can write
    a program that calculates the size of an object without using the
    built-in sizeof operator. It becomes a very worthwhile endeavor.

    That's the problem with a lot of the answers given here. They lack
    context.
    Kenny McCormack, May 12, 2008
    #8
  9. (Kenny McCormack) writes:

    > In article <>,
    > David Thompson <> wrote:
    >>On Wed, 30 Apr 2008 15:06:16 -0700 (PDT), user923005
    >><> wrote:
    >>
    >>> On Apr 30, 9:56 am, Eugeny Myunster <> wrote:
    >>> > Hello all,
    >>> >         How can i emulate sizeof()
    >>> >         only for integers?
    >>>
    >>> Of course, it is lunacy to use something else when you want a size,
    >>> since the sizeof operator is perfect for that task.

    >
    > It's not lunacy, if a woman tells you she'll sleep with you if can write
    > a program that calculates the size of an object without using the
    > built-in sizeof operator. It becomes a very worthwhile endeavor.
    >
    > That's the problem with a lot of the answers given here. They lack
    > context.


    I think the lack of context is more the problems of the question in this
    case.
    Eligiusz Narutowicz, May 12, 2008
    #9
  10. In article <g09ndo$d9$>,
    Eligiusz Narutowicz <> wrote:
    ....
    >> It's not lunacy, if a woman tells you she'll sleep with you if can write
    >> a program that calculates the size of an object without using the
    >> built-in sizeof operator. It becomes a very worthwhile endeavor.
    >>
    >> That's the problem with a lot of the answers given here. They lack
    >> context.

    >
    >I think the lack of context is more the problems of the question in this
    >case.
    >


    I think (against the tide, I understand) that you should assume that a
    poster has a reason for posting (as he does).

    He should not have to justify that position beyond that which the fact
    that he has posted has already done so.
    Kenny McCormack, May 12, 2008
    #10
  11. In article <g09ooa$om1$>,
    Kenny McCormack <> wrote:

    >I think (against the tide, I understand) that you should assume that a
    >poster has a reason for posting (as he does).


    Yes, but for most of these sizeof() questions the context seems most
    likely to be "I can't do the questions on my C test".

    -- Richard
    --
    :wq
    Richard Tobin, May 12, 2008
    #11
  12. In article <g09qnr$16he$>,
    Richard Tobin <> wrote:
    >In article <g09ooa$om1$>,
    >Kenny McCormack <> wrote:
    >
    >>I think (against the tide, I understand) that you should assume that a
    >>poster has a reason for posting (as he does).

    >
    >Yes, but for most of these sizeof() questions the context seems most
    >likely to be "I can't do the questions on my C test".
    >
    >-- Richard
    >--
    >:wq


    "Passing the class" is probably an even more important - and more deserving
    reason - than "I wanna get laid".
    Kenny McCormack, May 12, 2008
    #12
  13. On Apr 30, 8:26 pm, Kenneth Brody <> wrote:
    > Eugeny Myunster wrote:
    >
    > > Hello all,
    > >         How can i emulate sizeof()
    > >         only for integers?

    >
    > I'd really love to know which instructors keep giving this assignment.
    >
    > Why do you want to "emulate sizeof", when sizeof exists just for this
    > purpose?
    >
    > How about:
    >
    >     #define MySizeof(x) sizeof(x)
    >
    > Now you can "emulate sizeof" by using "MySizeof(int)", for example.
    >
    > --
    > +-------------------------+--------------------+-----------------------+
    > | Kenneth J. Brody        |www.hvcomputer.com| #include              |
    > | kenbrody/at\spamcop.net |www.fptech.com    |    <std_disclaimer.h> |
    > +-------------------------+--------------------+-----------------------+
    > Don't e-mail me at: <mailto:>


    I think it is a punishment for missing some homework or something. I
    totally agree with the Macro approach. Ask your instructor, What is
    the point of this assignment?, will I ever work on a project and try
    to emulate this?
    El-Hassan Wanas, May 12, 2008
    #13
  14. Kenny McCormack wrote:
    >
    > In article <g09qnr$16he$>,
    > Richard Tobin <> wrote:
    > >In article <g09ooa$om1$>,
    > >Kenny McCormack <> wrote:
    > >
    > >>I think (against the tide, I understand) that you should assume that a
    > >>poster has a reason for posting (as he does).

    > >
    > >Yes, but for most of these sizeof() questions the context seems most
    > >likely to be "I can't do the questions on my C test".

    >
    > "Passing the class" is probably an even more important - and more deserving
    > reason - than "I wanna get laid".


    Quandry:

    Professor says "get the size of an object without using sizeof".

    SO says "don't".

    --
    +-------------------------+--------------------+-----------------------+
    | Kenneth J. Brody | www.hvcomputer.com | #include |
    | kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h> |
    +-------------------------+--------------------+-----------------------+
    Don't e-mail me at: <mailto:>
    Kenneth Brody, May 14, 2008
    #14
    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. Derek
    Replies:
    7
    Views:
    24,303
    Ron Natalie
    Oct 14, 2004
  2. Trevor

    sizeof(str) or sizeof(str) - 1 ?

    Trevor, Apr 3, 2004, in forum: C Programming
    Replies:
    9
    Views:
    613
    CBFalconer
    Apr 10, 2004
  3. Vinu
    Replies:
    13
    Views:
    1,383
    Lawrence Kirby
    May 12, 2005
  4. blufox

    sizeof( int ) != sizeof( void * )

    blufox, May 22, 2006, in forum: C Programming
    Replies:
    2
    Views:
    543
    Joe Smith
    May 22, 2006
  5. Alex Vinokur
    Replies:
    7
    Views:
    486
    Clark S. Cox III
    Aug 14, 2006
Loading...

Share This Page