CppStory_Data.html
copyright © James Fawcett
Revised: 02/01/2025
copyright © James Fawcett
Revised: 02/01/2025
Chapter #3 - C++ Data Types and Data
sizes, initialization, standard types
3.0 Data Prologue
Quick Starter Example - Easy Data In & Out with std::tuple
- Template type deduction will be covered in Chapter6 - templates.
3.1 Types
- A set of allowed values
- Operations that may be applied to these values
- integral: byte, bool, int, char, char16_t, char32_t, wchar_t
- floating point: float, double
- derived types: array, pointer, reference
struct S { ... } class C { ... } enum class E { ... } - alias:
using [NewName] = [TypeName]
3.1.1 Type Qualifiers
const qualifier - const int i;
-
const prepended on a type declaration
const int ci; ci immutable -
function and method parameters
void f(const std:string& s) -
const postpended to a method declaration and definition
void X::f(int i) const { ... } x ε X , when invoked as x.f(i); -
const applied to pointers
const X* pX = &x X* const pX = &x
short and long Qualifiers - short int;
-
short prepended on a type definition for int
short int i; sizeof(short int) <= sizeof(int); -
long prepended on a type definition for int or double
long double d; sizeof(double) <= sizeof(long double) <= sizeof(long long double)
signed and unsigned Qualifiers - unsigned int;
-
signed (default) may be prepended on a type definition for int or char
signed int i; acceptable values of i occupy a range symmetric around the value 0 -
unsigned may be prepended on a type definition for int or char
unsigned int j; acceptable values of j lie in a range bounded at the bottom with 0
static Qualifier - static int;
-
static prepended on a local type definition (in a function)
static int i = 3; instructs the compiler to place storage for this named entity in static memory initialized to the value 3.The compiler initializes it exactly once, no later than the first function entry, and does not re-initialize on subsequent entries. The value persists across function calls, changing only when the function assigns to it. - static prepended on a member variable of a class or struct places that variable in static memory, so every instance of the class or struct shares the same value.
extern Qualifier - extern int;
-
extern prepended on a type definition at namespace or global scope
extern int i; provides a declaration, but instructs the compiler that another compilation unit (.cpp file) provides storage so it should not be provided in this compilation unit.
inline Qualifier - inline const int = 3;
-
inline prepended on a type definition in a header file
inline const double pi = 3.14159; instructs the linker to provide storage only once, even if the header file is included in multiple cpp files used to build one image.This eliminates one source of multiple definition linker errors.
volatile qualifier - volatile int i;
-
volatile prepended on a type definition
volatile int i; instructs compiler that variable i may be changed by an event external to the program and so should not be optimized to a compile-time constant.
constexpr qualifier - constexpr int N = 10;
-
constexpr prepended on a const integral type definition initialized with constant instance
constexpr int N = 10; We will discuss constexpr with if selection in the template meta-programming chapter.
3.1.2 Type Specifiers
auto and decltype specifiers - auto d{ 1.5 };
-
auto as a type definition
auto r{ 3 }; auto s{ 1.5 } r is type int ands is type double. -
auto is frequently used to deduce the type of a function return value or as the type of a variable enumerated in
a range-based for:
auto r = f();
for(auto item : container) { ... }
-
decltype as a type definition
decltype(make_lambda()) x;
3.2 Exploring Types
Example: Using sizeof and typeid to explain how lambdas work
Here is a template function, useful for exploring types, that uses both sizeof
and typeid :
template<typename T> void displayType(const T& t, const std::string& msg = "", bool showSize = true) { std::cout << "\n "; if (showSize) std::cout << sizeof(t) << " = size of "; std::string typeName = typeid(t).name(); if (typeName.size() > 75) typeName = typeName.substr(0, 75) + "..."; std::cout << typeName; if (msg.size() > 0) std::cout << msg; }
It provides one way to begin understanding how lambdas work:
int i{ 42 }; auto f = [i](const std::string& s) { std::cout << s << i; }; f("\n The meaning of life is "); displayType(f);
Here, f is a lambda declared with auto because the lambda type is unknown.
The [i] capture clause captures the value of i, which is 42.
The (const std::string& s) parameter passes a string by const reference to the lambda body.
The body { ... } displays the parameter and the captured integer.
The meaning of life is 42
4 = size of class <lambda_1bed100c18f4584a5d93f1a5d7e27280>
The displayType function reveals that the lambda is a class, discloses its type name
(not intended for human consumption), and shows that its size equals the captured int value.
class lambda_1bed1... {
public:
void operator()(const std::string& s) {
std::cout << s << i;
}
private:
int i = 42;
};
Lambdas can capture data and be passed into or returned from functions, carrying their data
with them (provided they hold values, not references). The lambda and its enclosing scope
form a closure. A lambda can use any data in its closure.
[i, j, x]
drawn from the lambda's closure, and (T1 arg1, T2 arg2, ... )
passed in from the scope where the lambda is invoked. The lambda's designer
provides the capture inputs and the lambda user provides the arguments.
3.3 Type Structure
- All of the fundamental types except floats have a simple structure consisting of a sequence of bytes in one location.
-
The float type partitions its storage into:
- 1 bit sign
- 8 bit exponent
- 23 bit fraction
-
The double type has the partitions:
- 1 bit sign
- 11 bit exponent
- 52 bit fraction
- Most values don't have exact representation. Integers all have exact floating-point representations, but numbers like 1.0/3.0 have infinitely many trailing digits, e.g., 0.33333333333333...., and are stored imprecisely.
- So these values have granularity with differences within granules that can't be represented.
- The size of the granularity depends on the magnitude of the float. The fractional value of one float may be the same as the fractional value of another, but if the exponent of one is larger than the other, the absolute values of granularity will differ.
- Two conceptually distinct floats may share the same floating-point representation, so use caution with equality comparisons.
- Repeating operations on a float in a loop can produce increasing error in computed results due to accumulated granularity errors.
-
Scientific computing, e.g., processing models for particles, gravity,
super-conductors, gene expression, climate dynamics, ... - Processing financial models for derivative and currency trading
- Graphics processing using projections and ray-tracing
- Medical imaging
- Radar and Sonar signal processing
- Finite-element analysis for fluid flow
- Navigation computing for aircraft and spacecraft
- Autonomous vehicle control.
- Neural network modeling
- Marketing models
- Control of machine tools used to create manufactured products
- ....
3.4 Managing C++ Type System with Casts
| static_cast Syntax | static_cast Symantics |
|---|---|
|
Convert |
Example: static_cast<T>
/*-------------------------------------------------------------------------------------- purpose of static_cast is to create a new instance of a destination type, based on data stored in the source type. --------------------------------------------------------------------------------------*/ int i = 1.75; // i = 1, with compiler warning of loss of significance int j = static_cast<int>(1.75); // j = 1, no compiler warning
| const_cast Syntax | const_cast Symantics |
|---|---|
|
|
Strip the const qualifier from a const type. The intent is to pass a const variable to platform API functions
that cannot declare themselves const, but are known not to change the variable. |
Example: const_cast<T>
/*-------------------------------------------------------------------------------------- purpose of const_cast is to allow passing const data to functions that won't change value even though not declared as const functions, OS API calls for example. --------------------------------------------------------------------------------------*/ void mockAPIfunction(std::string* pStr) { std::cout << "\n inside mock API function: " << *pStr; } void demoConstCast(const std::string& str) { displaySubtitle("const_cast"); std::cout << "\n " << str; //mockAPIfunction(&str); fails to compile since str is const /*--- useful operation using sRef ---*/ std::string& sRef = const_cast<std::string&>(str); // created non-const reference to const str mockAPIfunction(&sRef); // succeeds since sRef is not const /*--- evil operation on sRef, violates contract of function interface ---*/ /* don't do this */ sRef = "changed"; std::cout << "\n " << str; // now has changed value std::cout << "\n"; }
const_cast ------------ const string inside mock API function: const string changed
The compiler allows modifying the const_cast source, but you should never do that.
| dynamic_cast Syntax | dynamic_cast Symantics |
|---|---|
|
pDer->Derived::memFun(); } |
The intent is to call a |
Example: dynamic_cast<T>
/*-------------------------------------------------------------------------------------- dynamic_cast grants access to derived class interfaces starting with base pointer --------------------------------------------------------------------------------------*/ class Base { public: virtual ~Base() {} virtual void say() { std::cout << "\n hello from Base::say() via " << typeid(*this).name(); } }; class Derived1 : public Base { public: virtual ~Derived1() {} void say1() { std::cout << "\n hello from Derived1::say1() via " << typeid(*this).name(); } }; class Derived2 : public Base { public: virtual ~Derived2() {} void say2() { std::cout << "\n hello from Derived2::say2() via " << typeid(*this).name(); } }; auto putline = [](int n=1) { for(int i=0; i<n; ++i) std::cout << std::endl; }; void demoDynamicCast() { displaySubtitle("dynamic_cast"); std::cout << "\n --- calls from objects ---\n"; Base b; b.say(); putline(); Derived1 d1; d1.say(); d1.say1(); putline(); Derived2 d2; d2.say(); d2.say2(); putline(); std::cout << "\n --- call via base pointer ---\n"; Base* pBase = &d1; pBase->say(); // pBase->say1(); not accessible from B* putline(); std::cout << "\n --- call via dynamic_cast derived pointer ---\n"; Derived1* pDer1 = dynamic_cast<Derived1*>(pBase); if (pDer1) { pDer1->say1(); } putline(); }
dynamic_cast -------------- --- calls from objects --- hello from Base::say() via class Base hello from Base::say() via class Derived1 hello from Derived1::say1() via class Derived1 hello from Base::say() via class Derived2 hello from Derived2::say2() via class Derived2 --- call via base pointer --- hello from Base::say() via class Derived1 --- call via dynamic_cast derived pointer --- hello from Derived1::say1() via class Derived1
|
reinterpret_cast Syntax
|
reinterpret_cast Symantics |
|---|---|
|
|
Apply type rules of Usually used for packing data into byte arrays and unpacking back to original type. |
Example: reinterpret_cast<T>
/*-------------------------------------------------------------------------------------- purpose of reinterpret_cast is to apply new type rules to an existing instance. - packing double's bytes into byte array - unpacking byte array into another double - illustrates how data might be marshalled over a socket channel, where the byte array pretends to be the socket channel --------------------------------------------------------------------------------------*/ void demoReinterpretCast() { displaySubtitle("reinterpret_cast"); double d1{ 3.5 }; double d2; size_t Max = sizeof(d1); /* create byte array on heap referenced by std::unique_ptr<std::byte> */ std::unique_ptr<std::byte> pBuffer(new std::byte[Max]); // owning pointer std::byte* pBuffIndex = pBuffer.get(); // non-owning pointer /* pack double d1 into byte array */ std::byte* pByteSrc = reinterpret_cast<std::byte*>(&d1); std::byte* pSrcIndex = pByteSrc; // non-owning pointers for (size_t i = 0; i < Max; ++i) { *pBuffIndex++ = *pSrcIndex++; } /* unpack byte array into double d2 */ if (sizeof(d2) == sizeof(d1)) { std::byte* pByteDst = reinterpret_cast<std::byte*>(&d2); std::byte* pDstIndex = pByteDst; // non-owning pointers pBuffIndex = pBuffer.get(); for (size_t i = 0; i < Max; ++i) { *pDstIndex++ = *pBuffIndex++; } } /* show that src and dst have the same values */ std::cout << "\n src double = " << d1; std::cout << "\n dst double = " << d2; // byte array on heap will be deallocated here // as std::unique_ptr goes out of scope }
reinterpret_cast ------------------ src double = 3.5 dst double = 3.5
public:
operator Y () { ... }
};
Y y = x;
public:
explicit operator Y () { ... }
};
Y y = static_cast<Y>(x);
3.5 New Standard Types
| pair | contains two elements which may have distinct types |
| tuple | contains finite number of elements with distinct types |
| initializer_list | contains sequence of elements, all of the same type normally filled with initialization list, e.g., { 1, 2, 3, ... } |
| any | holds value of any type, provides std::any_cast for retrieval |
| optional | used to return values or signal failure to return |
| variant | similar to any, but only holds values from a specified set of types |
3.6 Initialization
- T t = u
- T t(u);
- T t = { u };
- T t{ u };
Examples of "uniform initialization"
double* pDouble{ &pi };
double& rDouble{ pi }; std::pair<int, double> pair1{ 4, 4.5 }; std::vector<std::pair<int, double>> pVec{ pair1, pair2, pair3, pair4 }; std::tuple<int, double, std::string> aTuple{ 1, 3.1415927, "some string" }; std::unordered_map<std::string, int> umap{ { "two", 2}, {"three", 3} }; std::unique_ptr<double> uPtr1{ std::make_unique<double>(pi) };
std::shared_ptr<double> sPtr1{ std::make_shared<double>(pi) };
Examples of "structured binding"
auto [d, i, s] = std::tuple<double, int, std::string>{ 2.5, 3, "four" }; struct S { int i; char c; std::string s; };
S foobar{ 2, 'Z', "a string" };
auto [fee, fie, foe] = foobar;
Note: Structured binding only works for public data in the source entity.
Example of where "structured binding" does not work.
public:
C(const std::string& str) : str_(str) {} // promotion ctor
void say() { std::cout << "\n " << str_; }
operator std::string() { return str_; } // cast operator
private:
std::string str_;
}; /* uniform initialization works with promotion ctors */
C c{ "hello world" };
/* these fail to compile: can only bind to public data */
//auto [gotit] {c};
//auto [gotit] = { static_cast
3.7 Managing Allocation with Smart Pointers
- No memory leaks, because smart pointers delete their allocations when they go out of scope.
- Users of factory functions that return smart pointers need not manage allocations - the smart pointers handle that.
Smart Pointers
-
All of the STL containers manage data with heap allocations except for the std::array . That class uses stack allocation for a fixed number of data items.
3.8 Building Data Structures with STL Containers
|
FileInfo from path ".." ------------------------- CallableObjects.cpp C:\github\JimFawcett\CppStory\Chapter3-CallableObjects Chap1.cpp C:\github\JimFawcett\CppStory\Chapter1 Chap1.h C:\github\JimFawcett\CppStory\Chapter1 Classes.cpp C:\github\JimFawcett\CppStory\Chapter4-classes Coercion.cpp C:\github\JimFawcett\CppStory\Chapter3-Coercion Cpp11-BlockingQueue.h C:\github\JimFawcett\CppStory\Chapter3-Logger CustomTraits.h C:\github\JimFawcett\CppStory\CustomTraits Data.cpp C:\github\JimFawcett\CppStory\Chapter2-Data DateTime.cpp C:\github\JimFawcett\CppStory\Chapter2-STL C:\github\JimFawcett\CppStory\Chapter3-Logger C:\github\JimFawcett\CppStory\DirWalker DateTime.h C:\github\JimFawcett\CppStory\Chapter2-STL C:\github\JimFawcett\CppStory\Chapter3-Logger C:\github\JimFawcett\CppStory\DirWalker Dev.cpp C:\github\JimFawcett\CppStory\Chapter1-Dev Dev.h C:\github\JimFawcett\CppStory\Chapter1-Dev DirWalker.cpp C:\github\JimFawcett\CppStory\Chapter2-STL C:\github\JimFawcett\CppStory\DirWalker DirWalker.h C:\github\JimFawcett\CppStory\Chapter2-STL C:\github\JimFawcett\CppStory\DirWalker Display.h C:\github\JimFawcett\CppStory\Chapter3-Logger C:\github\JimFawcett\CppStory\Display Functions.cpp C:\github\JimFawcett\CppStory\Chapter3-functions Functions1.cpp.html C:\github\JimFawcett\CppStory\Chapter3-functions IDev.h C:\github\JimFawcett\CppStory\Chapter1-Dev IPerson - Copy.h C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson.h C:\github\JimFawcett\CppStory\Chapter1-Dev C:\github\JimFawcett\CppStory\Chapter1-Person C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson1.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson2.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson3.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson4.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson5.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson6.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson7.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson8.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson9.h.html C:\github\JimFawcett\CppStory\Webber\ToHTML Init.cpp C:\github\JimFawcett\CppStory\Chapter2-Init Logger.cpp C:\github\JimFawcett\CppStory\Chapter3-Logger Logger.h C:\github\JimFawcett\CppStory\Chapter3-Logger Overloading.cpp C:\github\JimFawcett\CppStory\Chapter1-overloading Overriding.cpp C:\github\JimFawcett\CppStory\Chapter1-Overriding Overriding.h C:\github\JimFawcett\CppStory\Chapter1-Overriding Person.cpp C:\github\JimFawcett\CppStory\Chapter1-Dev C:\github\JimFawcett\CppStory\Chapter1-Person C:\github\JimFawcett\CppStory\Webber\ToHTML Person.h C:\github\JimFawcett\CppStory\Chapter1-Dev C:\github\JimFawcett\CppStory\Chapter1-Person C:\github\JimFawcett\CppStory\Webber\ToHTML PersonDisplay.h C:\github\JimFawcett\CppStory\Chapter1-Person PersonTest.cpp C:\github\JimFawcett\CppStory\Chapter1-PersonTest STL.cpp C:\github\JimFawcett\CppStory\Chapter3-STL STL_DataStructures.cpp C:\github\JimFawcett\CppStory\Chapter2-STL Sizes.cpp C:\github\JimFawcett\CppStory\Chapter2-sizes Survey.cpp C:\github\JimFawcett\CppStory\Chapter1-Survey TestDev.cpp C:\github\JimFawcett\CppStory\Chapter1-DevTest TestPerson.cpp C:\github\JimFawcett\CppStory\Chapter4-classes ToHTML.cpp C:\github\JimFawcett\CppStory\Webber\ToHTML const_cast.cpp C:\github\JimFawcett\CppStory const_cast1.cpp.html C:\github\JimFawcett\CppStory const_cast1.txt.html C:\github\JimFawcett\CppStory dynamic_cast.cpp C:\github\JimFawcett\CppStory dynamic_cast1.cpp.html C:\github\JimFawcett\CppStory dynamic_cast2.cpp.html C:\github\JimFawcett\CppStory reinterpret_cast.cpp C:\github\JimFawcett\CppStory reinterpret_cast1.cpp.html C:\github\JimFawcett\CppStory static_cast.cpp C:\github\JimFawcett\CppStory static_cast1.cpp.html C:\github\JimFawcett\CppStory number of files: 56 number of paths: 23 |
PathInfo from path ".." ------------------------- C:\github\JimFawcett\CppStory const_cast.cpp const_cast1.cpp.html const_cast1.txt.html dynamic_cast.cpp dynamic_cast1.cpp.html dynamic_cast2.cpp.html reinterpret_cast.cpp reinterpret_cast1.cpp.html static_cast.cpp static_cast1.cpp.html C:\github\JimFawcett\CppStory\Chapter1 Chap1.cpp Chap1.h C:\github\JimFawcett\CppStory\Chapter1-Dev Dev.cpp Dev.h IDev.h IPerson.h Person.cpp Person.h C:\github\JimFawcett\CppStory\Chapter1-DevTest TestDev.cpp C:\github\JimFawcett\CppStory\Chapter1-Overriding Overriding.cpp Overriding.h C:\github\JimFawcett\CppStory\Chapter1-Person IPerson.h Person.cpp Person.h PersonDisplay.h C:\github\JimFawcett\CppStory\Chapter1-PersonTest PersonTest.cpp C:\github\JimFawcett\CppStory\Chapter1-Survey Survey.cpp C:\github\JimFawcett\CppStory\Chapter1-overloading Overloading.cpp C:\github\JimFawcett\CppStory\Chapter2-Data Data.cpp C:\github\JimFawcett\CppStory\Chapter2-Init Init.cpp C:\github\JimFawcett\CppStory\Chapter2-STL DateTime.cpp DateTime.h DirWalker.cpp DirWalker.h STL_DataStructures.cpp C:\github\JimFawcett\CppStory\Chapter2-sizes Sizes.cpp C:\github\JimFawcett\CppStory\Chapter3-CallableObjects CallableObjects.cpp C:\github\JimFawcett\CppStory\Chapter3-Coercion Coercion.cpp C:\github\JimFawcett\CppStory\Chapter3-Logger Cpp11-BlockingQueue.h DateTime.cpp DateTime.h Display.h Logger.cpp Logger.h C:\github\JimFawcett\CppStory\Chapter3-STL STL.cpp C:\github\JimFawcett\CppStory\Chapter3-functions Functions.cpp Functions1.cpp.html C:\github\JimFawcett\CppStory\Chapter4-classes Classes.cpp TestPerson.cpp C:\github\JimFawcett\CppStory\CustomTraits CustomTraits.h C:\github\JimFawcett\CppStory\DirWalker DateTime.cpp DateTime.h DirWalker.cpp DirWalker.h C:\github\JimFawcett\CppStory\Display Display.h C:\github\JimFawcett\CppStory\Webber\ToHTML IPerson - Copy.h IPerson.h IPerson1.h.html IPerson2.h.html IPerson3.h.html IPerson4.h.html IPerson5.h.html IPerson6.h.html IPerson7.h.html IPerson8.h.html IPerson9.h.html Person.cpp Person.h ToHTML.cpp number of files: 56 number of paths: 23 |
3.9 Data Epilogue
3.10 Data - Programming Exercises
-
Write code that declares two floating point numbers and initializes one to a known value.
Write a function that, using pointers, copies each byte of the initialized number into
the other. Verify that after the copy both numbers hold the same value. Write another
function that compares the two numbers, byte by byte, using pointers.
You will want to ensure that no buffer overruns occur, by using the sizeof operator. - Write a function that accepts a string and returns a count of the number of words in the string. For this exercise assume that words always begin and end adjacent to whitespace characters excluding the beginning and end of the string.
-
Expand on the last exercise by building a key-value pair collection where the keys are
discovered words and the value is the number of times it occurs in the input string.
You may wish to look at
std::map<std::string, size_t> . Note that the first time you encounter a word your map will contain{ word, 1 } . If you encounter that word again you don't try to add as a new key. Instead you increment the value, e.g.,{ word, 2 } . - Extend this exercise one more time by creating a black-list of words not entered, e.g., articles and conjunctions: the, and, or, when, ... Look up each discovered word and enter into the map only if it is not on the black-list. That means you will look up every word, so you want to use a data structure that does look-ups efficiently.
3.11 References
Built-in types (C++) - MSDN
Types - austincc.edu/akochis
Sections
url
url