>#include <fstream.h>
While this may work on older compilers, the current C++ standard makes no mention of this header. Use <fstream> instead.

>void main ()
main does not, and never has, returned void. The following is the correct definition of main taking no arguments:
Code:
int main()
{
  // Stuff
}
Here is one way to do it properly:
Code:
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <string>

using namespace std;

int main()
{
  // 1
  string filename;

  // 2
  cout<<"Enter a file to open: ";

  // 3
  if ( !getline ( cin, filename ) ) {
    cerr<<"Input error"<<endl;
    return EXIT_FAILURE;
  }

  // 4
  ifstream in ( filename.c_str() );

  // 5
  if ( !in ) {
    cerr<<"Error opening file"<<endl;
    return EXIT_FAILURE;
  }

  // 6
  char ch;

  // 7
  while ( in.get ( ch ) )
    cout.put ( ch );

  // 8
  cout<<endl;

  // 9
  return EXIT_SUCCESS;
}
I've commented the areas that I'll...um...comment on.

1) The C++ string class is much better than C-style strings. You don't need to set a size for them because they grow to meet your needs, you don't have to worry about a trailing null character, and they have a slew of useful methods. I highly recommend you start out using C++ strings and then move on to C-style strings because they're actually harder.

2) Notice that there's no need to flush the stream if an input operation follows. This is a convenience born from experience with C.

3) getline is much better than cin's >> operator for reading string input. Not only do you avoid the issue where >> stops at whitespace, you also avoid the subtle bug of leaving junk in the stream for other input operations to break on.

4) Unless you have a very good reason, it's best to initialize objects when you define them. This is easily done with constructors.

5) Always, I'll say again, ALWAYS, check to see if your file is opened and ready to go. This is especially important here because the user (a notoriously inaccurate data entry mechanism) is supplying a file name.

6) It's good to declare your variables just before you need them. That way readers don't have to search all over the place to find where an uninformatively named variable (such as ch) is used.

7) cin and cout both have overloaded functions that handle single characters. What's even better is that the return value from get can be used as a condition for a loop. If it returns a true value then data was read and you can keep going. If it returns a false value then either there was a catastrophic error, or you reached the end of input...generally we suggest that you determine which of these is the case in real programs. But for now you can ignore it and assume end-of-file.

8) It's always a good idea to clean up the output stream for future programs. In this case I assume that the console window is shared and that printing another newline will allow the next program to start at column 0. Be a good neighbor.

9) EXIT_SUCCESS is equivalent to 0 and defined in <cstdlib> along with EXIT_FAILURE. Notice that I neglected to close the file as well. This is because the destructor does that for me. Unless you plan on using the object for opening another file or you don't plan on leaving the object's scope for a while, you can let the destructor handle closing and such.