Asking for Tips: Writing readable, beautiful code

[A-Man]

It has been a year and a half, and I think I have made lots of progress on this!

Here is a description of the style I've went with:
-Local variables are in lower case. Words are separated by the underscore character "_". e.g "blue_berry"
-Class member variables follow the above rule, except that they start with the underscore character "_".  e.g "_blue_berry"
Format:

• Class names are in upper camel case. e.g: "ObjectInstance".
  
• Functions which are in global scope are in camel case and first letter capitalized. e.g: "UpdateMode()"
  
• Class member function are in camel case, but the first letter isn't capitalized. e.g: "renderEntities()"
  
• Global variables / preprocessor defined values are in ALLCAPS.
  

After rereading this thread, it turned out there was one thing I left out, and that was the character per line limit =(. But I hope I will be able to get used to that as well.

Some other paradigms I follow:

• Longer self-explanatory variables all the way. While that can make a line of code much longer than it could be, I try not to use 1 character variable name ("i", "j"..etc in for loops) except in cases where the block of code is short enough.
  
• Not to use the default constructor when writing classes but get an "init()" function instead which takes the parameters and does the construction/initialization for you.
  

Finally, class files for stuff I've written recently (perhaps you could give it a skim and see if there you catch something I can improve):
http://pastebin.com/2YSsnLCG  #AExpression.h
http://pastebin.com/KmDzFgx6  #AExpression.cpp
http://pastebin.com/R6RWcKTE  #AScope.h
http://pastebin.com/WmWFuuWr  #AScope.cpp

I am still not the best with for loops and such, but I try to attain a balance between my focus on what the code does and its readability.

I'd be interested in listening to newer guys' opinions on this topic also.

[Azriel]

So, this is my 2c after working in a software company for a while.

@A-man:

• I used to write code like that, and actually I used to write it much, muuuch worse than that (to the point my current self got lost reading it ._.). You're on track to getting good; I think you're at the point that you need to see good practise code to produce it.
  
• The code you're showing is a parser, so it's going to be longer than "normal", but these functions are still quite big, and not "simple enough to understand by skimming":
  

  C++-Code: AExpression<numeraltype>::processScopeTokens(std::string expression_string) AExpression<numeraltype>::init AExpression<numeraltype>::handlePrecedenceOfOperators() AScope<numeraltype>::getFuncParameter(std::string line, int number)

  
  
• Reduce the number of lines per function, i.e. break down the function into calling smaller functions
  
• Make smaller classes, such that you have one class per responsibility. When I've got time I'll elaborate on this, but google for solid design principles.
  

[A-Man]

I used to write code like that, and actually I used to write it much, muuuch worse than that (to the point my current self got lost reading it ._.). You're on track to getting good; I think you're at the point that you need to see good practise code to produce it.

lol, thank you very much, glad to hear. I really need to start getting myself into the git community for feedback in what I do.

[*]The code you're showing is a parser, so it's going to be longer than "normal", but these functions are still quite big, and not "simple enough to understand by skimming":

Code:

AExpression<numeraltype>::processScopeTokens(std::string expression_string)
AExpression<numeraltype>::init
AExpression<numeraltype>::handlePrecedenceOfOperators()
AScope<numeraltype>::getFuncParameter(std::string line, int number)

There you knew it :P. But yes, I see your point. You, as someone who've done this as a profession and have worked with professionals, would you agree to say that it's better to avoid shortforms entirely in naming and stick to full forms even if the names grew long?

[*]Make smaller classes, such that you have one class per responsibility. When I've got time I'll elaborate on this, but google for solid design principles.

I don't know what other class I could've had in there. AExpressions compile and evaluate expressions, and AScope stores a scope or a "context" of defined variables and functions.

I have read some guides on structure and design, and together with your points, I started trying out different approaches which will hopefully end with better code.

I appreciate your time =)


@Someone else

One thing you can do is to split the function parameters across multiple lines like:

Code:

d3d_set_projection_ext(x,y,z,
                      x+sin(dir*pi/180)*cos(zdir*pi/180),y+cos(dir*pi/180)*cos(zdir*pi/180),z+sin(zdir),
                      0,0,1,angle,window_get_width()/window_get_height(),znear,zfar);

This is what I tend to do, but sometimes this can get completely overwhelming (or tiresome for the cpu since it passes a lot of bytes to the function)
In this case you can use a structure to store the values like:

Code:

typedef struct {
   double xfrom;
   double yfrom;
   double zfrom;
   double xto;
   double yto;
   double zto;
   double xup;
   double yup;
   double zup;
   unsigned int angle;
   float aspect;
   unsigned int znear;
   unsigned int zfar;
} ProjectStruct;

//...

ProjectStruct Projection;
Projection.xfrom = x;
//...

d3d_set_projection_ext(&Projection);

Were you talking about designing the function so that it takes a struct instead of multiple parameters or about another way to pass parameters, regardless of how many parameters it's prototyped to take, using a single object instance?

You left me quite confused there, because the compiler complains about the number of arguments, and at the same time the function sounds like something out from a library (direct3d).

[Som1Lse]

Were you talking about designing the function so that it takes a struct instead of multiple parameters or about another way to pass parameters, regardless of how many parameters it's prototyped to take, using a single object instance?

You left me quite confused there, because the compiler complains about the number of arguments, and at the same time the function sounds like something out from a library (direct3d).

My point was that if a function has a lot of parameters it could be easier to make it take a structure instead, but the way I did it in that example is not how I would do it.
If you had a function like that in your code I would make the individual coordinates into a single vector struct.
The function is from Game Maker.

If you want to discuss coding style more, the best place is probably on IRC as I can respond quicker there.