C++ Standard Dev

< cpp
C++
Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library(C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library(C++11)
Atomic operations library(C++11)
Thread support library(C++11)
Filesystem library(C++17)
Technical Specifications
C++ standard dev Standard Library headers
Language Support
<cfloat>
<cstdint>
<new>
<source_location>
<csignal>
<csetjmp>
<cstdarg>

Concepts
<concepts>
Diagnostics
General utilities
<utility>
<memory>
<memory_resource>
<scoped_allocator>
<compare>
<type_traits>
<ratio>
<chrono>
<typeindex>
<functional>
Strings
<string>
<string_view>
<cstring>
<cctype>
<cwctype>

Localization
Containers
<deque>
<forward_list>
<list>
<unordered_map>
<unordered_set>
<stack>
Iterators
<iterator>
Ranges
<ranges>
Algorithms
Numerics
<valarray>
<numeric>
<cfenv>
<cmath>
Input/Output
<istream>
<ostream>
<iostream>

<cstdio>
<cinttypes>
<strstream>

Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<shared_mutex>
<condition_variable>
<future>
<latch>
<barrier>

C compatibility
<cstdbool>
<ccomplex>

I started C this week and have been doing a little project. So i'm trying to calc standard deviation & variance. My code loads a file of 100 integers and put them into an array, counts them, calcs mean, sum, var and sd. But i'm having a little trouble with variance. I keep getting a huge number - i have a feeling it's to do with its calculation. C98 Support in GCC GCC has full support for the 1998 C standard as modified by the 2003 technical corrigendum and some later defect reports, excluding the export feature which was later removed from the language. This mode is the default in GCC versions prior to 6.1; it can be explicitly selected with the -std=c98 command-line flag, or -std=gnu98 to enable GNU extensions as well.

The interface of C++ standard library is defined by the following collection of headers.

Contents

  • 3Utilities library
  • 16C compatibility headers

Concepts library

<concepts>(since C++20)Fundamental library concepts

Coroutines library

<coroutine>(since C++20)Coroutine support library

Utilities library

<cstdlib> General purpose utilities: program control, dynamic memory allocation, random numbers, sort and search
<csignal> Functions and macro constants for signal management
<csetjmp> Macro (and function) that saves (and jumps) to an execution context
<cstdarg> Handling of variable length argument lists
<typeinfo> Runtime type information utilities
<typeindex>(since C++11)std::type_index
<type_traits>(since C++11)Compile-time type information
<bitset>std::bitset class template
<functional> Function objects, Function invocations, Bind operations and Reference wrappers
<utility> Various utility components
<ctime> C-style time/date utilites
<chrono>(since C++11) C++ time utilites
<cstddef> standard macros and typedefs
<initializer_list>(since C++11)std::initializer_list class template
<tuple>(since C++11)std::tuple class template
<any>(since C++17)std::any class
<optional>(since C++17)std::optional class template
<variant>(since C++17)std::variant class template
<compare>(since C++20)Three-way comparison operator support
<version>(since C++20) supplies implementation-dependent library information
<source_location>(since C++20) supplies means to obtain source code location
Dynamic memory management
<new> Low-level memory management utilities
<memory> Higher level memory management utilities
<scoped_allocator>(since C++11) Nested allocator class
<memory_resource>(since C++17) Polymorphic allocators and memory resources
Numeric limits
<climits> limits of integral types
<cfloat> limits of float types
<cstdint>(since C++11) fixed-size types and limits of other types
<cinttypes>(since C++11) formatting macros , intmax_t and uintmax_t math and conversions
<limits> standardized way to query properties of arithmetic types
Error handling
<exception> Exception handling utilities
<stdexcept> Standard exception objects
<cassert> Conditionally compiled macro that compares its argument to zero
<system_error>(since C++11) defines std::error_code, a platform-dependent error code
<cerrno> Macro containing the last error number

Strings library

<cctype> Functions to determine the type contained in character data
<cwctype> Functions to determine the type contained in wide character data
<cstring> various narrow character string handling functions
<cwchar> various wide and multibyte string handling functions
<cuchar>(since C++11) C-style Unicode character conversion functions
<string>std::basic_string class template
<string_view>(since C++17)std::basic_string_view class template
<charconv>(since C++17)std::to_chars and std::from_chars
<format>(since C++20)Formatting library including std::format

Containers library

<array>(since C++11)std::array container
<vector>std::vector container
<deque>std::deque container
<list>std::list container
<forward_list>(since C++11)std::forward_list container
<set>std::set and std::multiset associative containers
<map>std::map and std::multimap associative containers
<unordered_set>(since C++11)std::unordered_set and std::unordered_multiset unordered associative containers
<unordered_map>(since C++11)std::unordered_map and std::unordered_multimap unordered associative containers
<stack>std::stack container adaptor
<queue>std::queue and std::priority_queue container adaptors
<span>(since C++20)std::span view

Iterators library

<iterator> Range iterators

Ranges library

<ranges>(since C++20) Range access, primitives, requirements, utilities and adaptors

Algorithms library

<algorithm> Algorithms that operate on ranges
<execution>(since C++17) Predefined execution policies for parallel versions of the algorithms

Numerics library

<cmath> Common mathematics functions
<complex> Complex number type
<valarray> Class for representing and manipulating arrays of values
<random>(since C++11) Random number generators and distributions
<numeric> Numeric operations on values in containers
<ratio>(since C++11) Compile-time rational arithmetic
<cfenv>(since C++11) Floating-point environment access functions
<bit>(since C++20) Bit manipulation functions
<numbers>(since C++20) Math constants

Input/output library

<iosfwd> forward declarations of all classes in the input/output library
<ios>std::ios_base class, std::basic_ios class template and several typedefs
<istream>std::basic_istream class template and several typedefs
<ostream>std::basic_ostream, std::basic_iostream class templates and several typedefs
<iostream> several standard stream objects
<fstream>std::basic_fstream, std::basic_ifstream, std::basic_ofstream class templates and several typedefs
<sstream>std::basic_stringstream, std::basic_istringstream, std::basic_ostringstream class templates and several typedefs
<syncstream>(since C++20)std::basic_osyncstream, std::basic_syncbuf, and typedefs
<strstream>(deprecated in C++98)std::strstream, std::istrstream, std::ostrstream
<iomanip> Helper functions to control the format of input and output
<streambuf>std::basic_streambuf class template
<cstdio> C-style input-output functions

Localization library

<locale> Localization utilities
<clocale> C localization utilities
<codecvt>(since C++11)(deprecated in C++17) Unicode conversion facilities

Regular Expressions library

<regex>(since C++11) Classes, algorithms and iterators to support regular expression processing

Atomic Operations library

<atomic>(since C++11) Atomic operations library

Thread support library

<thread>(since C++11)std::thread class and supporting functions
<stop_token>(since C++20) Stop tokens for std::jthread
<mutex>(since C++11) mutual exclusion primitives
<shared_mutex>(since C++14) shared mutual exclusion primitives
<future>(since C++11) primitives for asynchronous computations
<condition_variable>(since C++11)thread waiting conditions
<semaphore>(since C++20)semaphores
<latch>(since C++20)latches
<barrier>(since C++20)barriers

Filesystem library

<filesystem>(since C++17)std::path class and supporting functions

[edit]C compatibility headers

For some of the C standard library headers of the form xxx.h, the C++ standard library both includes an identically-named header and another header of the form cxxx (all meaningful cxxx headers are listed above).

With the exception of complex.h , each xxx.h header included in the C++ standard library places in the global namespace each name that the corresponding cxxx header would have placed in the std namespace.

These headers are allowed to also declare the same names in the std namespace, and the corresponding cxxx headers are allowed to also declare the same names in the global namespace: including <cstdlib> definitely provides std::malloc and may also provide ::malloc. Including <stdlib.h> definitely provides ::malloc and may also provide std::malloc. This applies even to functions and function overloads that are not part of C standard library.

<assert.h>(deprecated) behaves as if each name from <cassert> is placed in global namespace
<ctype.h>(deprecated) behaves as if each name from <cctype> is placed in global namespace
<errno.h>(deprecated) behaves as if each name from <cerrno> is placed in global namespace
<fenv.h>(deprecated) behaves as if each name from <cfenv> is placed in global namespace
<float.h>(deprecated) behaves as if each name from <cfloat> is placed in global namespace
<inttypes.h>(deprecated) behaves as if each name from <cinttypes> is placed in global namespace
<limits.h>(deprecated) behaves as if each name from <climits> is placed in global namespace
<locale.h>(deprecated) behaves as if each name from <clocale> is placed in global namespace
<math.h>(deprecated) behaves as if each name from <cmath> is placed in global namespace
except for names of mathematical special functions
<setjmp.h>(deprecated) behaves as if each name from <csetjmp> is placed in global namespace
<signal.h>(deprecated) behaves as if each name from <csignal> is placed in global namespace
<stdarg.h>(deprecated) behaves as if each name from <cstdarg> is placed in global namespace
<stddef.h>(deprecated) behaves as if each name from <cstddef> is placed in global namespace
except for names of std::byte and related functions
<stdint.h>(deprecated) behaves as if each name from <cstdint> is placed in global namespace
<stdio.h>(deprecated) behaves as if each name from <cstdio> is placed in global namespace
<stdlib.h>(deprecated) behaves as if each name from <cstdlib> is placed in global namespace
<string.h>(deprecated) behaves as if each name from <cstring> is placed in global namespace
<time.h>(deprecated) behaves as if each name from <ctime> is placed in global namespace
<uchar.h>(deprecated) behaves as if each name from <cuchar> is placed in global namespace
<wchar.h>(deprecated) behaves as if each name from <cwchar> is placed in global namespace
<wctype.h>(deprecated) behaves as if each name from <cwctype> is placed in global namespace

[edit]Empty C headers

The headers <complex.h>, <ccomplex>, <tgmath.h>, and <ctgmath> do not contain any content from the C standard library and instead merely include other headers from the C++ standard library. The use of all these headers is deprecated in C++.

<ccomplex>(since C++11)(deprecated in C++17)(removed in C++20) simply includes the header <complex>
<complex.h>(deprecated) simply includes the header <complex>
<ctgmath>(since C++11)(deprecated in C++17)(removed in C++20) simply includes the headers <complex> and <cmath>: the overloads equivalent to the contents of the C header tgmath.h are already provided by those headers
<tgmath.h>(deprecated) simply includes the headers <complex> and <cmath>

[edit]Meaningless C headers

The headers <ciso646>, <cstdalign>, and <cstdbool> are meaningless in C++ because the macros they provide in C are language keywords in C++.

<ciso646>(removed in C++20) empty header. The macros that appear in iso646.h in C are keywords in C++
<iso646.h>(deprecated) has no effect
<cstdalign>(since C++11)(deprecated in C++17)(removed in C++20) defines one compatibility macro constant
<stdalign.h>(deprecated) defines one compatibility macro constant
<cstdbool>(since C++11)(deprecated in C++17)(removed in C++20) defines one compatibility macro constant
<stdbool.h>(deprecated) defines one compatibility macro constant

[edit]Unsupported C headers

The C headers <stdatomic.h>, <stdnoreturn.h>, and <threads.h> are not included in C++ and have no cxxx equivalents.

[edit]Experimental libraries

C++ TR's/TS's also define several collections of headers.

[edit]See also

C++ Standard Deviation

Retrieved from 'https://en.cppreference.com/mwiki/index.php?title=cpp/header&oldid=114097'
-->

This section of the documentation contains reference content for the Microsoft implementation of the ISO standard C and C++ languages. The language reference includes documentation for the preprocessor, compiler intrinsics, and supported assembly languages.

You'll also find documentation for the C runtime library, the C++ standard library, and several other libraries available with the Microsoft C/C++ compiler (MSVC) here.

Language reference

C language
Reference content for the Microsoft implementation of the C language.

C++ language
Reference content for the Microsoft implementation of the C++ language.

C/C++ preprocessor
Reference content for the preprocessor used by C and C++.

Compiler intrinsics
Describes intrinsic functions that are available in Microsoft C and C++ for x86, ARM, ARM64, and x64 architectures.

Dev C++ Free Download

Inline assembler
Explains how to use the Visual C/C++ inline assembler with x86 processors.

ARM assembler reference
Provides reference material for the Microsoft ARM assembler (ARMASM) and related tools.

C++ Standard Dev

Microsoft macro assembler reference
Provides reference material for the Microsoft Macro assembler (MASM).

Libraries reference

Standard libraries

C runtime library
The reference for the Microsoft implementation of the C runtime library (CRT), sometimes referred to as the Universal CRT.

C++ standard library
The reference for the Microsoft implementation of the C++ standard library.

Libraries for Windows applications

MFC/ATL
Documentation for the Microsoft Foundation Classes (MFC) and Active Template Library (ATL) class libraries.

Additional libraries

C++ AMP (C++ Accelerated Massive Parallelism)
Classes that enable the use of modern graphics processors for general purpose programming.

C++ Standard Deviation Eigen

Concurrency Runtime
Classes that simplify the writing of programs that use data parallelism or task parallelism.

OpenMP
Reference for the Microsoft implementation of the OpenMP API.

SafeInt library
A portable library that can be used with MSVC, GCC, or Clang to help prevent integer overflows.

Dev C++ Tutorial

Data Access LibrariesLibraries to support data access using ATL or MFC, and legacy services such as OLE DB and ODBC.

Related articles

Windows Runtime (WinRT) with C++
C++/WinRT is an entirely standard modern C++17 language projection for Windows Runtime (WinRT) APIs, implemented as a header-file-based library.

C++ Standard Deviation Of Array

Windows Runtime C++ Template Library (WRL)
A legacy template library for the Windows Runtime, replaced by C++/WinRT.