File input/output: Difference between revisions

</Ada>

The following solution uses stream I/O. Any file of Ada.Text_IO can be used to obtain a corresponding stream. Reading and writing streams is more efficient than reading text files directly, because it skips formatting. Note also how End_Error exception is used to avoid End_Of_File. End_Of_File is depreciated as it requires file look-ahead, and thus is much less efficient.

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Text_IO.Text_Streams; use Ada.Text_IO.Text_Streams;

Close (Outfile);

end File_IO;

=={{header|ALGOL 68}}==

PROC copy file = (STRING in name, out name)VOID: (

A couple of remarks on the preceding example:

 

 

It uses buffered IO to perform the move, which is overkill. This is not actually a weakness, but it invokes some overhead that you don't need.

=={{header|C++}}==

{{works with|g++|3.4.2}}

#include <fstream>

#include <string>

}

return 0;

 

Simpler version:

 

#include <fstream>

#include <cstdlib>

return EXIT_SUCCESS;

 

Using istream- and ostream- iterators:

 

# include <fstream>

 

std::istreambuf_iterator<char>(),

std::ostreambuf_iterator<char>(ofile));

 

Even simpler way:

 

 

int main()

std::ofstream output("output.txt");

output << input.rdbuf();

 

=={{header|Clean}}==

do (write-sequence buffer out :end size))))

 

 

=={{header|Delphi}}==

=={{header|OCaml}}==

By line:

let ic = open_in "input.txt" in

let oc = open_out "output.txt" in

close_in ic;

close_out oc;

 

By character:

let ic = open_in "input.txt" in

let oc = open_out "output.txt" in

close_in ic;

close_out oc;

 

(Notice that ic and oc, of type ''in_channel'' and ''out_channel'', are buffered)

The following use of the standard libraries shutil.copyfile is to be preferred. (Current source code ensures that failure to open files raises appropriate exceptions, a restricted buffer is used to copy the files using binary mode, and any used file descriptors are always closed).

 

 

However the following example shows how one would do file I/O of other sorts:

 

infile = open('input.txt', 'r')

outfile = open('output.txt', 'w')

outfile.close()

infile.close()

 

This does no error checking. A more robust program would wrap each open with exception handling blocks:

 

import sys

try:

infile.close()

outfile.close()

 

In Python 2.6 (or 2.5 if we use ''from __future__ import with_statement'') we can more simply write:

 

import sys

try:

sys.exit(1)

 

 

The files will automatically be closed on exit of their ''with:'' blocks. (Thus even if an I/O error occurred while reading the middle of the input file we are assured that the ''.close()'' method will have been called on each of the two files.