1. Iostream.h Dev C 2b 2b 1b
2. Iostream.h Dev C 2b 2b 2c

In the C++programming language, input/output library refers to a family of class templates and supporting functions in the C++ Standard Library that implement stream-based input/output capabilities.^[1][2] It is an object-oriented alternative to C's FILE-based streams from the C standard library.^[3][4]

History[edit]

Bjarne Stroustrup, the creator of C++, wrote the first version of the stream I/O library in 1984, as a type-safe and extensible alternative to C's I/O library.^[5] The library has undergone a number of enhancements since this early version, including the introduction of manipulators to control formatting, and templatization to allow its use with character types other than char.

The correct code is code cpp#include /code, try that (and watch the space between them, too). In C you don't add the '.h' for things in the standard library - When can you omit the file extension in an #include directive? Fungsi File Header Pada Program C - Dalam membuat suatu bahasa pemrograman C kita harus menulis File Header terlebih dahulu, lalu apa itu File Header pada C? File Header pada C adalah pernyataan pendeklarasian utama pada sebuah program C yang berfungsi untuk memanggil dan menjalan fungsi-fungsi yang terdapat dalam library file header C agar kita dapat menggunakan fungsi pada file. C Syntax: Input/Output: Description Standard Streams The standard I/O system is declared in the header file:- #include iostream.h I/O sources and sinks are called streams. C Function Call (Accessing, Invoking, Executing) Tutorial - A function is called or invoked or executed by providing the function name, followed by the parameters being sent enclosed in parentheses. In the C programming language, input/output library refers to a family of class templates and supporting functions in the C Standard Library that implement stream-based input/output capabilities. It is an object-oriented alternative to C's FILE-based streams from the C standard library. C program to find Square Root of a Number. For calculate Square Root of a number we multiply number by 0.5 because square root of any number means power of 1/2 and 1/2=0.5. And one another method for this program is use sqrt function it is pre-defined in math.h header file.

Standardization in 1998 saw the library moved into the std namespace, and the main header changed from <iostream.h> to <iostream>. It is this standardized version that is covered in the rest of the article.

Overview[edit]

Most of the classes in the library are actually very generalized class templates. Each template can operate on various character types, and even the operations themselves, such as how two characters are compared for equality, can be customized. However, the majority of code needs to do input and output operations using only one or two character types, thus most of the time the functionality is accessed through several typedefs, which specify names for commonly used combinations of template and character type.

For example, basic_fstream<CharT,Traits> refers to the generic class template that implements input/output operations on file streams. It is usually used as fstream which is an alias for basic_fstream<char,char_traits<char>>, or, in other words, basic_fstream working on characters of type char with the default character operation set.

The classes in the library could be divided into roughly two categories: abstractions and implementations. Classes, that fall into abstractions category, provide an interface which is sufficient for working with any type of a stream. The code using such classes doesn't depend on the exact location the data is read from or is written to. For example, such code could write data to a file, a memory buffer or a web socket without a recompilation. The implementation classes inherit the abstraction classes and provide an implementation for concrete type of data source or sink. The library provides implementations only for file-based streams and memory buffer-based streams.

The classes in the library could also be divided into two groups by whether it implements low-level or high-level operations. The classes that deal with low-level stuff are called stream buffers. They operate on characters without providing any formatting functionality. These classes are very rarely used directly. The high-level classes are called streams and provide various formatting capabilities. They are built on top of stream buffers.

The following table lists and categorizes all classes provided by the input-output library.

Header files[edit]

The classes of the input/output library reside in several headers.

• <ios> contains the definitions of ios_base and basic_ios classes, that manage formatting information and the associated stream-buffer.
• <istream> contains the definition of basic_istream class template, which implements formatted input.
• <ostream> contains the definition of basic_ostream class template, which implements formatted output.
• <iostream> contains the definition of basic_iostream class template, which implements formatted input and output, and includes <ios>, <istream> and <ostream>.
• <fstream> contains the definitions of basic_ifstream, basic_ofstream and basic_fstream class templates which implement formatted input, output and input/output on file streams.
• <sstream> contains the definitions of basic_istringstream, basic_ostringstream and basic_stringstream class templates which implement formatted input, output and input/output on string-based streams.
• <iomanip> contains formatting manipulators.
• <iosfwd> contains forward declarations of all classes in the input/output library.

Stream buffers[edit]

There are twelve stream buffer classes defined in the C++ language as the table.

Support classes[edit]

ios_base and basic_ios are two classes that manage the lower-level bits of a stream. ios_base stores formatting information and the state of the stream. basic_ios manages the associated stream-buffer. basic_ios is commonly known as simply ios or wios, which are two typedefs for basic_ios with a specific character type. basic_ios and ios_base are very rarely used directly by programmers. Usually, their functionality is accessed through other classes such as iostream which inherit them.^[6][7]

Typedefs[edit]

Formatting manipulators[edit]

Input/output streams[edit]

C++input/output streams are primarily defined by iostream, a header file that is part of the C++ standard library (the name stands for Input/Output Stream). In C++ and its predecessor, the C programming language, there is no special syntax for streaming data input or output. Instead, these are combined as a library of functions. Like the cstdio header inherited from C's stdio.h, iostream provides basic input and output services for C++ programs. iostream uses the objectscin, cout, cerr, and clog for sending data to and from the standard streams input, output, error (unbuffered), and log (buffered) respectively. As part of the C++ standard library, these objects are a part of the stdnamespace.^[8]

The cout object is of type ostream, which overloads the left bit-shiftoperator to make it perform an operation completely unrelated to bitwise operations, and notably evaluate to the value of the left argument, allowing multiple operations on the same ostream object, essentially as a different syntax for method cascading, exposing a fluent interface. The cerr and clog objects are also of type ostream, so they overload that operator as well. The cin object is of type istream, which overloads the right bit-shift operator. The directions of the bit-shift operators make it seem as though data is flowing towards the output stream or flowing away from the input stream.

Output formatting[edit]

Methods[edit]

Manipulators[edit]

Manipulators are objects that can modify a stream using the << or >> operators.

Other manipulators can be found using the header iomanip.

Criticism[edit]

Some environments do not provide a shared implementation of the C++ library. These include embedded systems and Windows systems running programs built with MinGW. Under these systems, the C++ standard library must be statically linked to a program, which increases the size of the program,^[9] or distributed as a shared library alongside the program.Some implementations of the C++ standard library have significant amounts of dead code. For example, GNU libstdc++ automatically constructs a locale when building an ostream even if a program never uses any types (date, time or money) that a locale affects,^[10]and a statically linked 'Hello, World!' program that uses <iostream> of GNU libstdc++ produces an executable an order of magnitude larger than an equivalent program that uses <cstdio>.^[11]

There exist partial implementations of the C++ standard library designed for space-constrained environments; their <iostream> may leave out features that programs in such environments may not need, such as locale support.^[12]

Naming conventions[edit]

Examples[edit]

The canonical 'Hello, World!' program can be expressed as follows:

This program would output 'Hello, world!' followed by a newline and standard output stream buffer flush.

The following example creates a file called 'file.txt' and puts the text 'Hello, world!' followed by a newline into it.

References[edit]

1. ^ISO/IEC 14882:2003 Programming Languages — C++. [lib.string.streams]/1
2. ^Stanley B. Lippman, Josee Lajoie (1999). C++ Primer (third ed.). Massachusetts: Addison-Wesley. pp. 1109–1112. ISBN0-201-82470-1.
3. ^Bjarne Stroustrup (1997). The C++ programming language (third ed.). Addison-Wesley. pp. 637–640. ISBN0-201-88954-4.
4. ^Stanley B. Lippman, Josee Lajoie (1999). C++ Primer (third ed.). Massachusetts: Addison-Wesley. pp. 1063–1067. ISBN0-201-82470-1.
5. ^Bjarne Stroustrup. 'A History of C++: 1979–1991'(PDF).
6. ^Stanley B. Lippman, Josee Lajoie (1999). C++ Primer (third ed.). Massachusetts: Addison-Wesley. pp. 1112–1120. ISBN0-201-82470-1.
7. ^'<ios> Visual Studio 2010'. Microsoft MSDN: Visual Studio 2010. Retrieved 28 September 2011.
8. ^Holzner, Steven (2001). C++ : Black Book. Scottsdale, Ariz.: Coriolis Group. p. 584. ISBN1-57610-777-9. ..endl, which flushes the output buffer and sends a newline to the standard output stream.
9. ^'MinGW.org: Large executables'. Retrieved 22 April 2009.
10. ^GNU libstdc++ source code, bits/ios_base.h
11. ^C++ vs. C - Pin Eight
12. ^'uClibc++ C++ library'. Retrieved 6 January 2012.

External links[edit]

• C++ Basics

• C++ Object Oriented

• C++ Advanced

• C++ Useful Resources

• Selected Reading

Consider a situation, when we have two persons with the same name, Zara, in the same class. Whenever we need to differentiate them definitely we would have to use some additional information along with their name, like either the area, if they live in different area or their mother’s or father’s name, etc.

Same situation can arise in your C++ applications. For example, you might be writing some code that has a function called xyz() and there is another library available which is also having same function xyz(). Now the compiler has no way of knowing which version of xyz() function you are referring to within your code.

A namespace is designed to overcome this difficulty and is used as additional information to differentiate similar functions, classes, variables etc. with the same name available in different libraries. Using namespace, you can define the context in which names are defined. In essence, a namespace defines a scope.

Defining a Namespace

A namespace definition begins with the keyword namespace followed by the namespace name as follows −

To call the namespace-enabled version of either function or variable, prepend (::) the namespace name as follows −

Let us see how namespace scope the entities including variable and functions −

If we compile and run above code, this would produce the following result −

The using directive

You can also avoid prepending of namespaces with the using namespace directive. This directive tells the compiler that the subsequent code is making use of names in the specified namespace. The namespace is thus implied for the following code −

If we compile and run above code, this would produce the following result −

The ‘using’ directive can also be used to refer to a particular item within a namespace. For example, if the only part of the std namespace that you intend to use is cout, you can refer to it as follows − X craft tron 5000 driver download.

Subsequent code can refer to cout without prepending the namespace, but other items in the std namespace will still need to be explicit as follows −

Iostream.h Dev C 2b 2b 1b

If we compile and run above code, this would produce the following result −

Names introduced in a using directive obey normal scope rules. The name is visible from the point of the using directive to the end of the scope in which the directive is found. Entities with the same name defined in an outer scope are hidden.

Discontiguous Namespaces

A namespace can be defined in several parts and so a namespace is made up of the sum of its separately defined parts. The separate parts of a namespace can be spread over multiple files.

So, if one part of the namespace requires a name defined in another file, that name must still be declared. Writing a following namespace definition either defines a new namespace or adds new elements to an existing one −

Nested Namespaces

Namespaces can be nested where you can define one namespace inside another name space as follows −

You can access members of nested namespace by using resolution operators as follows −

In the above statements if you are using namespace_name1, then it will make elements of namespace_name2 available in the scope as follows −

Iostream.h Dev C 2b 2b 2c

If we compile and run above code, this would produce the following result −