File input/output: Difference between revisions

 

 

=={{header|Ada}}==

Input, Output : File_Type;

begin

end loop;

Close (Input);

Close (Output);

 

begin

end loop;

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

begin

loop

end loop;

exception

when End_Error =>

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

=={{header|AppleScript}}==

 

 

 

 

 

 

}

 

 

 

 

{

}

 

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

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

#include <fstream>

#include <string>

if (output.is_open()) {

if (input.is_open()){

output << line << endl;

}

}

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}}==

Define a function that copies the content from one file to another.

 

 

Apply this function to the world to copy a file.

 

 

=={{header|ColdFusion}}==

 

 

=={{header|Common Lisp}}==

By lines:

 

 

By arbitrary blocks and for possibly-binary files:

 

 

If you're on an odd platform which actually stores text/binary/... type information for files and your CL implementation will use this information, then <tt>in</tt> should be opened with <tt>:element-type :default</tt>.

 

=={{header|Delphi}}==

'''- Text File I/O -'''

 

f : TextFile ;

s : string ;

ReadLn(F,S);

CloseFile(

 

 

This is perhaps one of the most powerful I/O functions built into Pascal. This will allow you to open and read a file of ANY type, regardless of structure, size or content. Note the usage of Reset(). This is using the optional size parameter that instructs the record size of file I/O. This could have been called with SizeOf(Buff) as the optional parameter but that would have limited flexibility. Calling it with a size of ONE byte allows you to adjust the buffer size on the fly, as conditions warrant. Also note the use of the BytesRead parameter. When included in the BlockRead() function it will return the number of bytes actually read. If this is not included, then if your directive to read n bytes is greater then the size of the file, the EOF will be encountered unexpectedly and EIOError will be raised.

 

f : File ;

buff : array[1.1024] of byte ;

Blockread(f,Buff,SizeOf(Buff),BytesRead);

CloseFile(f);

 

'''- Typed File I/O -'''

Typed file I/O is very useful when reading and writing structures. An Address List is quiet easy to write when using this type of I/O. The same file procedures are used with some subtle differences. Bite below in the blockread and blockwrite procedures that the bytes to read or write are 1. Also note that the reset procedure is not called with a buffer size. When performing '''Typed File I/O''' the size of the type definition is the buffer size. In the BlockRead() and BlockWrite() procedures I elected to read '''one record'''. Had I declared a very large buffer of type tAddressBook of say 500 records, I could have set bytes to read as SizeOf(Buffer) thereby reading a minimum of 500 records.

 

 

tAddressBook = Record

BlockWrite(f,v,1,bytes);

CloseFile(f);

 

=={{header|E}}==

{{works with|E-on-Java}}

 

(This version holds the entire contents in memory.)

 

=={{header|Forth}}==

Forth traditionally has not had any file handling capabilities, preferring instead to operate on a disk image block by block. Most modern Forth systems however run under an existing operating system and provide methods for disk access.

 

 

 

 

Also, abort" can be used instead of throw if desired.

 

=={{header|Groovy}}==

 

Using File

 

Using Ant

 

Buffered

 

=={{header|Haskell}}==

Note: this doesn't keep the file in memory. Buffering is provided by lazy evaluation.

 

=={{header|IDL}}==

 

 

=={{header|J}}==

 

 

=={{header|Java}}==

{{works with|GCJ|4.1.2}}

Simple version; Files ''may'' be closed automatically by OS, on some systems.

 

 

 

 

{{works with|Java|1.4}}

'''Package''' [[nio]]

 

 

This version is more in line with the other languages' implementations: it assumes simple text files, and doesn't worry too much about errors (just throws them out to the caller, the console in this case). It's shorter and simpler and shows that simple programs can be simple to write, in Java as well.

 

}

}

 

=={{header|MAXScript}}==

 

=={{header|mIRC Scripting Language}}==

 

{{works with|mIRC}}

}

 

=={{header|Objective-C}}==

 

 

 

 

=={{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)

 

=={{header|Perl}}==

 

{{works with|Perl|5.8.8}}

 

Perl has also a powerful mechanism in conjunction with opening files called IO disciplines. It allows you to automatically apply chainable transformations on the input and output. Mangling newlines, gzip (de)compression and character encoding are the most used examples.

 

=={{header|PHP}}==

 

{{works with|PHP|4}}

{{works with|PHP|5}}

 

=={{header|Pop11}}==

Char by char copy:

 

 

Low level block copy:

 

 

 

 

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:

 

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

for line in infile:

outfile.write(line)

outfile.close()

 

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

 

try:

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

finally:

infile.close()

 

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

 

try:

with open('input.txt') as infile:

except IOError:

print >> sys.stderr, "Some I/O Error occurred"

 

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.

 

 

 

 

 

 

 

=={{header|Raven}}==

 

=={{header|Ruby}}==

 

=={{header|Standard ML}}==

{{works with|SML/NJ|110.59}}