Not a very good Idea!

Discussion in 'C Programming' started by vashwath@rediffmail.com, Apr 4, 2005.

  1. Guest

    Hi all,
    As per our coding rule, a line should not have more than 80 characters.
    When accessing a structure elements which are deeply nested, we are not
    able follow this rule. To acheive this Can we use macro?

    For example,

    struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;

    #define STRUCT2 struct2.str2.st1.s1
    #define STRUCT3 struct3.str3.st3.s3

    and then use

    struct1.str1.strct3 = STRUCT2 + STRUCT3;

    Is this a good Idea(if not please let me know what are the problems it
    may cause)?Or Is there a better Idea than this?
     
    , Apr 4, 2005
    #1
    1. Advertising

  2. On Mon, 3 Apr 2005 wrote:
    >
    > Hi all,
    > As per our coding rule, a line should not have more than 80 characters.
    > When accessing a structure elements which are deeply nested, we are not
    > able follow this rule. To acheive this Can we use macro?


    Oh, dear.

    > For example,
    >
    > struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;


    First of all, that's fewer than 80 columns. Secondly, the C programming
    language is whitespace-insensitive (in most ways), so you can always write

    struct1.str1.strct3 = struct2.str2.st1.s1
    + struct3.str3.st3.s3;

    A much better alternative is to rework your data structure, and use the
    much simpler

    x = y + z;

    Of course, this will require getting rid of a lot of tiny intermediate
    struct definitions (struct1, str1, st1, s1, and so on). But that's a
    very good thing. Nested structs are bad for readability, and mostly bad
    for thinking in general.

    If you can't do that (for example, if you have more silly "house rules"
    that require lots of nested data structures), you can use

    struct foo *p = &struct2.str2.st1;
    struct foo *q = &struct3.str3.st3;

    struct1.str1.strct3 = p->s1 + q->s3;

    Again, not the best solution, but a darn sight better than trying to
    use the preprocessor to wiggle out of a problem you yourself created
    with nested data structures.

    HTH,
    -Arthur
     
    Arthur J. O'Dwyer, Apr 4, 2005
    #2
    1. Advertising

  3. writes:
    > As per our coding rule, a line should not have more than 80 characters.
    > When accessing a structure elements which are deeply nested, we are not
    > able follow this rule. To acheive this Can we use macro?
    >
    > For example,
    >
    > struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;
    >
    > #define STRUCT2 struct2.str2.st1.s1
    > #define STRUCT3 struct3.str3.st3.s3
    >
    > and then use
    >
    > struct1.str1.strct3 = STRUCT2 + STRUCT3;
    >
    > Is this a good Idea(if not please let me know what are the problems it
    > may cause)?Or Is there a better Idea than this?


    struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;

    is obviously less than 80 columns, but assuming it's meant as an
    example, there's no reason it all has to be on one line. The
    following are equivalent:

    struct1.str1.strct3 =
    struct2.str2.st1.s1 + struct3.str3.st3.s3;

    struct1.str1.strct3 =
    struct2.str2.st1.s1 +
    struct3.str3.st3.s3;

    struct1
    .str1
    .strct3
    =
    struct2
    .str2
    .st1
    .s1
    +
    struct3
    .str3
    .st3
    .s3;

    It would probably be even better to restructure your code so you're
    not using so many deeply nested structures.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
    We must do something. This is something. Therefore, we must do this.
     
    Keith Thompson, Apr 4, 2005
    #3
  4. pete Guest

    Keith Thompson wrote:

    > struct1.str1.strct3 =
    > struct2.str2.st1.s1 +
    > struct3.str3.st3.s3;


    I prefer to start, rather than to terminate,
    a continued line with a binary operator,
    to make it more obvious that it's a continued line.

    struct1.str1.strct3
    = struct2.str2.st1.s1
    + struct3.str3.st3.s3;

    --
    pete
     
    pete, Apr 4, 2005
    #4
  5. wrote:
    >
    > Hi all,
    > As per our coding rule, a line should not have more than 80 characters.
    > When accessing a structure elements which are deeply nested, we are not
    > able follow this rule. To acheive this Can we use macro?
    >
    > For example,
    >
    > struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;
    >
    > #define STRUCT2 struct2.str2.st1.s1
    > #define STRUCT3 struct3.str3.st3.s3
    >
    > and then use
    >
    > struct1.str1.strct3 = STRUCT2 + STRUCT3;
    >
    > Is this a good Idea


    No.

    > (if not please let me know what are the problems it
    > may cause)?


    Difficult to read, difficult to debug when it goes wrong.

    > Or Is there a better Idea than this?


    Use a C99 compiler or a compiler that understand inline and
    use something like


    static inline void
    struct_add (STRUCT_NAME *result, const STRUCT_NAME *left, const STRUCT_NAME *right)
    { result->whatever.result = left->x.y.z + right->x.y.z ;
    }

    and you can call that using:

    struct_add (&result, &left, &right) ;
    
    if they are defined as structs or

    struct_add (result, left, right) ;

    if you already have pointers to the structs.

    Erik
    --
    +-----------------------------------------------------------+
    Erik de Castro Lopo (Yes it's valid)
    +-----------------------------------------------------------+
    Learning Linux is like joining a cult. Sure it's fun at first but
    you waste time, become brainwashed, and then have to be de-programmed
    by Bill Gates before you can work for Him again.
    - Ray Lopez, in UFhK4.33289$
     
    Erik de Castro Lopo, Apr 4, 2005
    #5
  6. CBFalconer Guest

    wrote:
    >
    > As per our coding rule, a line should not have more than 80
    > characters. When accessing a structure elements which are deeply
    > nested, we are not able follow this rule. To acheive this Can we
    > use macro?
    >
    > For example,
    >
    > struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;
    >
    > #define STRUCT2 struct2.str2.st1.s1
    > #define STRUCT3 struct3.str3.st3.s3
    >
    > and then use
    >
    > struct1.str1.strct3 = STRUCT2 + STRUCT3;
    >
    > Is this a good Idea(if not please let me know what are the
    > problems it may cause)?Or Is there a better Idea than this?


    Not in my opinion. It shows up the lack of a 'with' statement in
    C, but that is another matter. You can simply break the statement
    up:

    struct1.str1.strct3 = struct2.str2.st1.s1
    + struct3.str3.st3.s3;

    I also consider an 80 char line length excessive, 72 is better. If
    you are continuously falling off the right it probably indicates
    that you are failing to break your code up into small enough
    modules.

    --
    "If you want to post a followup via groups.google.com, don't use
    the broken "Reply" link at the bottom of the article. Click on
    "show options" at the top of the article, then click on the
    "Reply" at the bottom of the article headers." - Keith Thompson
     
    CBFalconer, Apr 4, 2005
    #6
  7. Eric Sosman Guest

    wrote:
    > Hi all,
    > As per our coding rule, a line should not have more than 80 characters.
    > When accessing a structure elements which are deeply nested, we are not
    > able follow this rule. To acheive this Can we use macro?
    >
    > For example,
    >
    > struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;


    Others have mentioned various ways of inserting line
    breaks to keep individual lines short, but I have not yet
    seen anything as radical as

    struct1
    .
    str1
    .
    strct3
    =
    struct2
    .
    str2
    .
    st1
    .
    s1
    +
    struct3
    .
    str3
    .
    st3
    .
    s3
    ;

    (The reason for exhibiting this abomination is to raise
    the important question: What is the problem your "coding rule"
    seeks to solve or avoid? When the rule makes trouble it is
    time to ask whether the cure is worse than the disease; this
    will guide you in deciding whether to bend the rule or to uphold
    it and make changes elsewhere.)

    --
    Eric Sosman
    lid
     
    Eric Sosman, Apr 4, 2005
    #7
  8. On Mon, 04 Apr 2005 11:34:58 +0000, CBFalconer wrote:

    ....

    > Not in my opinion. It shows up the lack of a 'with' statement in
    > C, but that is another matter.


    IMO Pascal's with statement is one of the truely nasty parts of that
    language. C has a vastly better way of dealing with that problem using
    pointers to structures or unions. In effect you can create a with
    construct where each structure being aliased is named explicitly.

    > You can simply break the statement
    > up:
    >
    > struct1.str1.strct3 = struct2.str2.st1.s1
    > + struct3.str3.st3.s3;


    Yes, there are lots of ways of handling this, this looks good here.
    Intermediaries could be appropriate in some circumstances, e.g.

    s2211 = struct2.str2.st1.s1;
    s3333 = struct3.str3.st3.s3;
    struct1.str1.strct3 = s2211 + s3333;

    Using with-like pointers could be natural if you access a number of
    members from an innermost structure

    type *const p221 = &struct2.str2.st1;
    type *const p333 = &struct3.str3.st3;

    struct1.str1.strct3 = p221->s1 + p333->s3;

    struct2.str3.strct1 = p221->s3 + p333->s1; /* for example */

    This can work for the LHS too.

    > I also consider an 80 char line length excessive, 72 is better. If
    > you are continuously falling off the right it probably indicates
    > that you are failing to break your code up into small enough
    > modules.


    It is very easy to get to and beyond 80 columns, although I try to limit
    myself to that for C code. It depends on indentation amount, expression
    complexity, whether you have some reasonable length text in string
    literals and so on. Making modules (do you mean functions?) too small is
    not a good thing, it creates complexity in the interfaces and call tree.

    Lawrence
     
    Lawrence Kirby, Apr 4, 2005
    #8
  9. Alan Balmer Guest

    On Mon, 04 Apr 2005 09:50:17 GMT, pete <> wrote:

    >Keith Thompson wrote:
    >
    >> struct1.str1.strct3 =
    >> struct2.str2.st1.s1 +
    >> struct3.str3.st3.s3;

    >
    >I prefer to start, rather than to terminate,
    >a continued line with a binary operator,
    >to make it more obvious that it's a continued line.
    >
    >struct1.str1.strct3
    > = struct2.str2.st1.s1
    > + struct3.str3.st3.s3;


    An interesting take. I generally read code from top to bottom, so
    prefer the binary operator on the end of the line, to make it more
    obvious that there's more to come.

    --
    Al Balmer
    Balmer Consulting
     
    Alan Balmer, Apr 4, 2005
    #9
  10. Keith Thompson wrote:
    >> As per our coding rule, a line should not have more than 80 characters.
    >> When accessing a structure elements which are deeply nested, we are not
    >> able follow this rule. To acheive this Can we use macro?
    >>
    >> For example,
    >>
    >> struct1.str1.strct3=struct2.str2.st1.s1 + struct3.str3.st3.s3;
    >> ...

    > ...
    > is obviously less than 80 columns, but assuming it's meant as an
    > example, there's no reason it all has to be on one line. The
    > following are equivalent:
    >
    > struct1.str1.strct3 =
    > struct2.str2.st1.s1 + struct3.str3.st3.s3;
    >
    > struct1.str1.strct3 =
    > struct2.str2.st1.s1 +
    > struct3.str3.st3.s3;
    >
    > struct1
    > .str1
    > .strct3
    > =
    > struct2
    > .str2
    > .st1
    > .s1
    > +
    > struct3
    > .str3
    > .st3
    > .s3;
    > ...


    And there's always the '\' at the end of line, which greatly expands the
    number of variants this code can be reformatted

    struct1.s\
    tr1.strct\
    3 = struc\
    t2.str2.s\
    t1.s1 + s\
    truct3.st\
    r3.st3.s3;

    Of course, professional programmers always format their code so that the
    way the code looks reflects what this code does. The above, for example,
    is a nice way to format a code that calculates the area of a rectangle.

    :)

    --
    Best regards,
    Andrey Tarasevich
     
    Andrey Tarasevich, Apr 4, 2005
    #10
  11. pete wrote on 04/04/05 :
    > Keith Thompson wrote:
    >
    >> struct1.str1.strct3 =
    >> struct2.str2.st1.s1 +
    >> struct3.str3.st3.s3;

    >
    > I prefer to start, rather than to terminate,
    > a continued line with a binary operator,
    > to make it more obvious that it's a continued line.
    >
    > struct1.str1.strct3
    > = struct2.str2.st1.s1
    > + struct3.str3.st3.s3;


    Agreed.

    --
    Emmanuel
    The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
    The C-library: http://www.dinkumware.com/refxc.html

    ..sig under repair
     
    Emmanuel Delahaye, Apr 4, 2005
    #11
  12. In article <>,
    Emmanuel Delahaye <> wrote:
    >pete wrote on 04/04/05 :
    >> I prefer to start, rather than to terminate,
    >> a continued line with a binary operator,
    >> to make it more obvious that it's a continued line.


    >> struct1.str1.strct3
    >> = struct2.str2.st1.s1
    >> + struct3.str3.st3.s3;


    >Agreed.



    FORTRAN lives ;-)

    (and, no, I didn't mean "Fortran").
    --
    Usenet is like a slice of lemon, wrapped around a large gold brick.
     
    Walter Roberson, Apr 4, 2005
    #12
  13. On Mon, 04 Apr 2005 10:17:19 -0700, Alan Balmer
    <> wrote:

    > On Mon, 04 Apr 2005 09:50:17 GMT, pete <> wrote:
    >
    >>Keith Thompson wrote:
    >>
    >>> struct1.str1.strct3 =
    >>> struct2.str2.st1.s1 +
    >>> struct3.str3.st3.s3;

    >>
    >>I prefer to start, rather than to terminate,
    >>a continued line with a binary operator,
    >>to make it more obvious that it's a continued line.
    >>
    >>struct1.str1.strct3
    >> = struct2.str2.st1.s1
    >> + struct3.str3.st3.s3;

    >
    > An interesting take. I generally read code from top to bottom, so
    > prefer the binary operator on the end of the line, to make it more
    > obvious that there's more to come.


    I do as well, but it's a style thing (roughly half of us at work prefer
    the operators at the end and the others prefer them at the start of the
    next line).

    There is no "one true way"...

    Chris C
     
    Chris Croughton, Apr 4, 2005
    #13
  14. Ian Pilcher Guest

    Chris Croughton wrote:
    > There is no "one true way"...


    You're new around here, aren't you?

    --
    ========================================================================
    Ian Pilcher
    ========================================================================
     
    Ian Pilcher, Apr 4, 2005
    #14
  15. In article <>,
    Ian Pilcher <> wrote:
    :Chris Croughton wrote:
    :> There is no "one true way"...

    :You're new around here, aren't you?

    Apparently, for half of us, it would have been fine if you had written,

    You
    're new around here
    , aren't you?
    --
    "[...] it's all part of one's right to be publicly stupid." -- Dave Smey
     
    Walter Roberson, Apr 5, 2005
    #15
  16. "CBFalconer" <> wrote in message
    news:...
    > wrote:
    >
    > I also consider an 80 char line length excessive, 72 is better.
    >


    Yes, please. My Teletype is only 72 columns...

    Rufus
     
    Rufus V. Smith, Apr 7, 2005
    #16
  17. On Thu, 7 Apr 2005 11:01:30 -0400, in comp.lang.c , "Rufus V. Smith"
    <> wrote:

    >
    >"CBFalconer" <> wrote in message
    >news:...
    >> wrote:
    >>
    >> I also consider an 80 char line length excessive, 72 is better.
    >>

    >
    >Yes, please. My Teletype is only 72 columns...


    you should try reading
    this stuff on an
    internet-enabled
    digital watch....

    --
    Mark McIntyre
    CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
    CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>
     
    Mark McIntyre, Apr 7, 2005
    #17
  18. In article <1112886039.35604f388b6a67a07b1128bf3c3273d9@teranews>, 0001
    Rufus V. Smith <> wrote: 0002
    >> I also consider an 80 char line length excessive, 72 is better. 0003

    0004
    >Yes, please. My Teletype is only 72 columns... 0005

    0006
    And for those of us using punched cards, if you use more than 72 0007
    characters it will run in to the sequence numbers. 0008
    0009
    -- Richard 0010
    0011
     
    Richard Tobin, Apr 7, 2005
    #18
  19. CBFalconer Guest

    "Rufus V. Smith" wrote:
    > "CBFalconer" <> wrote in message
    >> wrote:
    >>
    >> I also consider an 80 char line length excessive, 72 is better.

    >
    > Yes, please. My Teletype is only 72 columns...


    Mine too. However 72 also allows for 80 char text output after
    inserting line numbers, and avoids most line wrapping when quoted
    on usenet, etc. etc. In fact I try to limit my lines to 65 chars.
    This also tends to increase legibility.

    --
    "If you want to post a followup via groups.google.com, don't use
    the broken "Reply" link at the bottom of the article. Click on
    "show options" at the top of the article, then click on the
    "Reply" at the bottom of the article headers." - Keith Thompson
     
    CBFalconer, Apr 7, 2005
    #19
    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 Arthur St. Marie II of III

    very Very VERY dumb Question About The new Set( ) 's

    Raymond Arthur St. Marie II of III, Jul 23, 2003, in forum: Python
    Replies:
    4
    Views:
    484
    Raymond Hettinger
    Jul 27, 2003
  2. shanx__=|;-

    very very very long integer

    shanx__=|;-, Oct 16, 2004, in forum: C Programming
    Replies:
    19
    Views:
    1,634
    Merrill & Michele
    Oct 19, 2004
  3. Abhishek Jha

    very very very long integer

    Abhishek Jha, Oct 16, 2004, in forum: C Programming
    Replies:
    4
    Views:
    429
    jacob navia
    Oct 17, 2004
  4. Replies:
    10
    Views:
    1,244
    Big K
    Feb 2, 2005
  5. Peter

    Very very very basic question

    Peter, Feb 8, 2005, in forum: C Programming
    Replies:
    14
    Views:
    520
    Dave Thompson
    Feb 14, 2005
Loading...

Share This Page