I totally agree to what Jerry Jongerius says:

Use a debugger only as last resort. Having to resort to a debugger means your programming methodologies have failed.

I totally agree to what Jerry Jongerius says:

I guess everyone has heard about the Promo event :cheesy: (just kidding)

For anyone intrested in actually saving time while coding and to know of the best programming practices i actually recommend "The C++ programming languguage" by the inventor of C++.

Personally i feel that the code should be organized in the following way:

1. Header file (one per class) and each header having minimalistic clutter. I personally feel that developing good programming practices is a matter of experience, the more you are exposed everyday to correct modular programming practices the more your skills will be honed. Just having the knowledge of modular programming practices does not suffice. (Header.h)

2. Implementation of Header file (Header.cpp)

3. Driver file which utilises the above two files (Driver.cpp)

Hope it helped, bye.

I guess everyone has heard about the Promo event :cheesy: (just kidding)

What does this mean? Is this an inside joke?:cry:

What does this mean? Is this an inside joke?:cry:

Even I am not sure what he meant but I didn't ask because that would have spoiled his fun :D

Even I am not sure what he meant but I didn't ask because that would have spoiled his fun :D

See Wolfpack's signature...

See Wolfpack's signature...

Ah, now I get it.
He recently changed the signature but this tip came before that :mrgreen:

Use a descriptive name for the type. If you are having difficulty in finding a name for the type, you should do some more research about the type. You still don't know enough about what you want to implement.

Not sure if this belongs here, but non-the-less it has saved me LOT of time when I've to work with someone else's code. :)
Use Astyle to format the C, C++, C#, and Java code.
Download
Documentation
Project Home

DISCLAIMER:
Be warned, if you're scared of blind tool runs that modify code, don't use this. If you use it on production/customer-release code be sure to test. :).

Post your tips for making life easier in C and C++. I'll start:

Standard vector object initialization

The biggest problem with the standard vector class is that one can't use an array initializer. This forces us to do something like this:

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  vector<int> v;

  v.push_back(1);
  v.push_back(2);
  v.push_back(3);
  v.push_back(4);
  v.push_back(5);

  // Use the vector
}

Anyone who's had the rule of redundancy pounded into their head knows that the previous code could be wrapped in a loop:

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  vector<int> v;

  for (int i = 1; i < 6; i++)
    v.push_back(i);

  // Use the vector
}

However, it's not terribly elegant, especially for a vector of complex types. So, Narue's first timesaving tip for C++ is to use a temporary array so that you can make use of an initializer. Because the vector class defines a constructor that takes a range of iterators, you can use the array to initialize your vector:

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  int a[] = {1,2,3,4,5};
  vector<int> v(a, a + 5);

  // Use the vector
}

So here's what happened.
I was on DaniWeb getting help, and while waiting on someone to reply I looked through the sticky threads. I sent my C++ professor the link to Performance Tips and this thread on Thursday (i think). He sent me a message back saying he liked the one about vector something or other.
So on Friday morning he tells the class he added two slides (he uses powerpoint with most of his lectures), and one of them was because of a tip on the website I go to (daniweb :)). I attached one of the slides he added.

Congrats Narue! :D

using boost.assign http://www.boost.org/libs/assign/doc/index.html is the easiest way to fill containers; and it also works with containers other than vector<>.

#include <vector>
#include <list>
#include <map>
#include <string>
#include <boost/assign.hpp>
using namespace std;
using namespace boost::assign;

int main()
{
  vector<string> strings = list_of("abcd")("efg").repeat(5,"hi")("jkl") ;
  // "abcd" "efg" "hi" "hi" "hi" "hi" "hi" "jkl"
  strings += "mnop", "qrs", "tuvwx", "yz" ;
  // "abcd" "efg" "hi" "hi" "hi" "hi" "hi" "jkl" "mnop" "qrs" "tuvwx" "yz"
  
  list<int> numbers = list_of(100).repeat(7,22)(75)(80)(85)(90)(83) ;
  numbers += 555, 666, 1, 2, 3, repeat(4,99), 56, 75, 80 ;
  
  map<string,int> pbook = map_list_of("abcd",100)("efg",75)("hi",83) ;
  insert(pbook)("mnop",555)("qrs",4)("tuvwx",999)("yz",56) ;
}

where is narue? even if daniweb does not miss her, the c++ forum does.

Referring to Mr.BountyX tips on time saving ,,
"I know this may not seem like a super time saving technique, but the way you name your variables will help save time and reduce compile time errors.."

Yes indeed. This helps a lot.

Variable Naming conventions are very important in programming and it also reduces the code reviewing time a lot .

Eg:

consider a program which has

int RecId;

For a novel programmer who is looking at your code , may wonder at a particular point of the code about the data type of the variable.
b'coz "RecId" doesnt anyhow says whether it is a integer or string or char .

Some thing like this would help the programmer easily to understand ...

int nRecID.

The ' n ' at the begin says it as integer. so when ever someone look at it he can easily understand
datatype of the variable instead of looking at the declaration again ..

Famous conventions:
eg:

int nNumber;
string sData;
float fVal
CString csData;

For Global variable's prefix it like
' g_VARIABLENAME''

C++ STL

vector vec_nVal; // Store elements into vector ... // Accessing vector elements :

int ninitialize; for ( ninitialize = 0 ; ninitialize < vec_nVal.size() ; ninitialize++ ) { int nVal = vec_nVal[ninitialize];

cout<< nVal ; }

Two Time saving Tips;
1.Try avoiding function call at the for loop condition check
for ( ninitialize = 0 ; ninitialize < vec_nVal.size() ; i++ )

Function calls are costlier . So in the above code , for every iteration,vector::size() function will be called , which is not recommended
unless or otherwise if you know that vector size is going to change inside the loop .

For example : If the vector contains 100K elements then vector::size will be called 100K times.

so the best practice will be like , getting the size of the vector before the loop begin and substitute the variable accordingly . something like this ..."int nVecSize = vec_nVal.size();
for ( ninitialize = 0 ; ninitialize < nVecSize ; i++ ) "

2 .Use Iterators
One of the main concept of stl's are iterator. use it when ever required .

The above sample program can be written like this for the best performance and time saving .

vector::iterator itrNumber; itrNumber = vec_nVal.begin();

while( itrNumber != vec_nVal.end()) { int nVal =*(itrNumber ); cout< by using iterator the element retrieval time will be faster when compare to the previous one[ vector[] ] .

The same holds good for all stl containers . (eg:stl::map)

I am so sure that the above one will improve your performance and save your time leap and bound if you are using it excessively.

W.r.t std::vector.... Especially while loading ( doing a push_back )if u already know the the number of elements to be inserted then u can reserve it before u start loading. Use the reserve(...) function.

This was asked in another forum I go to and I came up with the following:

Reading contents of a file directly to a vector

#include <fstream>
#include <vector>
#include <string>
#include <algorithm>

int main( void ) {
  std::ifstream in( "shorts.txt", std::ios::binary );

  if ( in ) {
    std::vector< short > vs;
    vs.insert( vs.begin(), std::istream_iterator<short>(in), std::istream_iterator<short>() );
    std::copy( vs.begin(), vs.end(), std::ostream_iterator<short>(std::cout, "\n"));
  }

  return 0;
}

It's along the same lines as Naure's 'printing vector contents without a loop' trick. Use with caution though. Especially if you have a mix of types:

#include <fstream>
#include <vector>
#include <string>
#include <algorithm>

int main( void ) {
  std::ifstream in( "shorts.txt", std::ios::binary );

  if ( in ) {
    std::vector<short>        vshort;
    std::vector<std::string>  vstr;


    // Read shorts until fail
    vshort.insert( vshort.end(), std::istream_iterator<short>(in),       std::istream_iterator<short>() ); 
    // Clear stream
    in.clear();

    // Read strings until fail, inadvertently reads to end of file. 
    vstr.insert( vstr.end(),     std::istream_iterator<std::string>(in), std::istream_iterator<std::string>() );

    std::copy( vshort.begin(), vshort.end(), std::ostream_iterator<short>(std::cout, "\n") );
    std::copy( vstr.begin(),   vstr.end(),   std::ostream_iterator<std::string>(std::cout, "\n") );
  }

  return 0;
}

Will store numbers in the vector of strings until it fails. Then after clearing the stream it'll read in the rest of the contents until finished. But of course this is the case in all file IO.

tips
1 . use loops
2. use pointer
3.use functions
4. use method overloading
5 use typedef for initialisation