To develop a software based on “Test Driven Development” one should follow the following steps:

1)Write enough failing Test Code (include compile time and run time failures)
2)Write Production code to pass the failing tests.
3)Refactor the production code and verify the same with existing test.
4)Go to step 1

1)Write enough failing Test Code (include compile time and run time failures)

2)Write Production code to pass the failing tests.

3)Refactor the production code and verify the same with existing test.

4)Go to step 1

so let say we want to develop a binary search tree, here I’m using Google Test.

Step 1, Write enough failing Test Code

so the first step would be something like this:

class testingTree: public ::testing::Test
{
protected:
    testingTree(){}
    ~testingTree(){}
    void SetUp(){}
    void TearDown(){}
};

TEST_F(testingTree,makeTree)
{
    std::shared_ptr<Tree> tree=makeTree();
    EXPECT_NE(tree.get(),nullptr);
}


int main(int argc, char ** argv)
{
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

class testingTree: public ::testing::Test

{

protected:

testingTree(){}

~testingTree(){}

void SetUp(){}

void TearDown(){}

};

TEST_F(testingTree,makeTree)

{

std::shared_ptr<Tree> tree=makeTree();

EXPECT_NE(tree.get(),nullptr);

}

int main(int argc, char ** argv)

{

testing::InitGoogleTest(&argc, argv);

return RUN_ALL_TESTS();

}

Step 2, Write Production code to pass the failing tests.

The code from first step will fail during compilation, so the next step is to add the production code such that we can compile and pass the test:

class Tree
{
public:
    std::array<std::shared_ptr<Tree>,2 > leaves;
    /*
    tree->leaves[0] left node
    tree->leaves[1] right node
    */
    double data;
};

std::shared_ptr<Tree> makeTree(double data)
{
    return nullptr;
}

class Tree

{

public:

std::array<std::shared_ptr<Tree>,2 > leaves;

tree->leaves[0] left node

tree->leaves[1] right node

double data;

};

std::shared_ptr<Tree> makeTree(double data)

{

return nullptr;

}

Now this will give us a test failure:

Expected: (tree) != (nullptr), actual: NULL vs (nullptr)
[  FAILED  ] testingTree.makeTree (0 ms)
[----------] 1 test from testingTree (1 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (1 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] testingTree.makeTree

 1 FAILED TEST

Expected: (tree) != (nullptr), actual: NULL vs (nullptr)

[ FAILED ] testingTree.makeTree (0 ms)

[----------] 1 test from testingTree (1 ms total)

[----------] Global test environment tear-down

[==========] 1 test from 1 test suite ran. (1 ms total)

[ PASSED ] 0 tests.

[ FAILED ] 1 test, listed below:

[ FAILED ] testingTree.makeTree

1 FAILED TEST

and by adding more production code:

std::shared_ptr<Tree> makeTree(double data)
{
    std::shared_ptr<Tree> tree(new Tree(data));
    tree->data=data;
    return tree;
}

std::shared_ptr<Tree> makeTree(double data)

{

std::shared_ptr<Tree> tree(new Tree(data));

tree->data=data;

return tree;

}

this will pass the test.

Step 3, Refactor the production code

step 3 is refactoring, by doing refactoring we can clean our code to this:

class Tree
{
public:
    Tree(double data):data(data){}
    std::array<std::shared_ptr<Tree>,2 > leaves;
    /*
    tree->leaves[0] left node
    tree->leaves[1] right node
    */
    double data;
};

std::shared_ptr<Tree> makeTree(double data)
{
    std::shared_ptr<Tree> tree(new Tree(data));
    return tree;
}

class Tree

{

public:

Tree(double data):data(data){}

std::array<std::shared_ptr<Tree>,2 > leaves;

tree->leaves[0] left node

tree->leaves[1] right node

double data;

};

std::shared_ptr<Tree> makeTree(double data)

{

std::shared_ptr<Tree> tree(new Tree(data));

return tree;

}

Now we have to jump step1 again, add more test and continue.

class Tree
{
public:
    Tree(double data):data(data){}
    std::array<std::shared_ptr<Tree>,2 > leaves;
    /*
    tree->leaves[0] left node
    tree->leaves[1] right node
    */
    double data;
};

std::shared_ptr<Tree> makeTree(double data)
{
    std::shared_ptr<Tree> tree(new Tree(data));
    return tree;
}

void insertNode(std::shared_ptr<Tree> tree, double data)
{
    while(1)
    {
        if(data>tree->data)
        {
            if(tree->leaves[1] ==nullptr)
            {
                tree->leaves[1]=makeTree(data);
                break;
            }
            else
            {
                tree=tree->leaves[1];
                continue;
            }
        }
        else if(data<tree->data)
        {
            if(tree->leaves[0]==nullptr)
            {
                tree->leaves[0]=makeTree(data);
                break;
            }
            else
            {
                tree=tree->leaves[0];
                continue;
            }
        }
        else
        {
            std::cout<<"no duplicate" <<std::endl;
        }
    }
}

void DFS(std::shared_ptr<Tree> rootNode)
{
    std::cout<<rootNode->data <<std::endl;
    for(auto n:rootNode->leaves)
    {
        if(n!=nullptr)
            DFS(n);
    }
}

class testingTree: public ::testing::Test
{
protected:
    testingTree(){}
    ~testingTree(){}
    void SetUp(){}
    void TearDown(){}
};

TEST_F(testingTree,makeTree)
{
    std::shared_ptr<Tree> tree=makeTree(-1);
    EXPECT_NE(tree.get(),nullptr);
}

TEST_F(testingTree,traverseTree)
{
    int value=5;
    std::shared_ptr<Tree> tree=makeTree(value);


/*
                    5
                  /   \
                3       7
              /  \    /
             4    1  6
*/
    insertNode(tree,3);
    insertNode(tree,7);
    insertNode(tree,4);
    insertNode(tree,1);
    insertNode(tree,6);
    DFS(tree);
}


int main(int argc, char ** argv)
{
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

100

101

102

103

104

105

106

107

class Tree

{

public:

Tree(double data):data(data){}

std::array<std::shared_ptr<Tree>,2 > leaves;

tree->leaves[0] left node

tree->leaves[1] right node

double data;

};

std::shared_ptr<Tree> makeTree(double data)

{

std::shared_ptr<Tree> tree(new Tree(data));

return tree;

}

void insertNode(std::shared_ptr<Tree> tree, double data)

{

while(1)

{

if(data>tree->data)

{

if(tree->leaves[1] ==nullptr)

{

tree->leaves[1]=makeTree(data);

break;

}

else

{

tree=tree->leaves[1];

continue;

}

else if(data<tree->data)

{

if(tree->leaves[0]==nullptr)

{

tree->leaves[0]=makeTree(data);

break;

}

else

{

tree=tree->leaves[0];

continue;

}

else

{

std::cout<<"no duplicate" <<std::endl;

}

void DFS(std::shared_ptr<Tree> rootNode)

{

std::cout<<rootNode->data <<std::endl;

for(auto n:rootNode->leaves)

{

if(n!=nullptr)

DFS(n);

}

class testingTree: public ::testing::Test

{

protected:

testingTree(){}

~testingTree(){}

void SetUp(){}

void TearDown(){}

};

TEST_F(testingTree,makeTree)

{

std::shared_ptr<Tree> tree=makeTree(-1);

EXPECT_NE(tree.get(),nullptr);

}

TEST_F(testingTree,traverseTree)

{

int value=5;

std::shared_ptr<Tree> tree=makeTree(value);

/ \

3 7

/ \ /

4 1 6

insertNode(tree,3);

insertNode(tree,7);

insertNode(tree,4);

insertNode(tree,1);

insertNode(tree,6);

DFS(tree);

}

int main(int argc, char ** argv)

{

testing::InitGoogleTest(&argc, argv);

return RUN_ALL_TESTS();

}

Dijkstra’s algorithm with C++

Leave a reply

Dijkstra’s algorithm is an algorithm for finding the shortest path in a graph.
First drawing the graph:

import networkx as nx
import matplotlib.pyplot as plt
from networkx.drawing.nx_agraph import write_dot, graphviz_layout


def coloring_tree(G):

    visited_list=[]
    for i in G.nodes():
        visited_list.append( g.nodes[i]['visited'] )
    
    graph_color_map=[]
    for i  in visited_list:
        graph_color_map.append('red')
        
    pos =graphviz_layout(G, prog='dot')
    labels = nx.get_edge_attributes(G,'weight')
    nx.draw(G,pos,with_labels=True, arrows=True, node_color =  graph_color_map)
    nx.draw_networkx_edge_labels(G, pos,edge_labels=labels)
    plt.show()
    
    return

g=nx.DiGraph()
g.add_node('a',visited=False)
g.add_node('b',visited=False)
g.add_node('c',visited=False)
g.add_node('d',visited=False)
g.add_node('e',visited=False)
g.add_node('f',visited=False)
g.add_node('g',visited=False)
g.add_node('h',visited=False)
g.add_node('i',visited=False)


g.add_edge('a','b',weight=4)
g.add_edge('a','h',weight=8)


g.add_edge('b','a',weight=4)
g.add_edge('b','c',weight=8)
g.add_edge('b','h',weight=11)


g.add_edge('c','b',weight=8)
g.add_edge('c','d',weight=7)
g.add_edge('c','f',weight=4)
g.add_edge('c','i',weight=2)

g.add_edge('d','d',weight=7)
g.add_edge('d','e',weight=9)
g.add_edge('d','f',weight=14)

g.add_edge('e','d',weight=9)
g.add_edge('e','f',weight=10)

g.add_edge('f','c',weight=4)
g.add_edge('f','d',weight=14)
g.add_edge('f','e',weight=10)
g.add_edge('f','g',weight=2)

g.add_edge('g','f',weight=2)
g.add_edge('g','h',weight=1)
g.add_edge('g','i',weight=6)


g.add_edge('h','a',weight=8)
g.add_edge('g','b',weight=11)
g.add_edge('h','g',weight=1)
g.add_edge('h','i',weight=7)

g.add_edge('i','c',weight=2)
g.add_edge('i','g',weight=6)
g.add_edge('i','h',weight=7)

coloring_tree(g)

import networkx as nx

import matplotlib.pyplot as plt

from networkx.drawing.nx_agraph import write_dot, graphviz_layout

def coloring_tree(G):

visited_list=[]

for i in G.nodes():

visited_list.append( g.nodes[i]['visited'] )

graph_color_map=[]

for i in visited_list:

graph_color_map.append('red')

pos =graphviz_layout(G, prog='dot')

labels = nx.get_edge_attributes(G,'weight')

nx.draw(G,pos,with_labels=True, arrows=True, node_color = graph_color_map)

nx.draw_networkx_edge_labels(G, pos,edge_labels=labels)

plt.show()

return

g=nx.DiGraph()

g.add_node('a',visited=False)

g.add_node('b',visited=False)

g.add_node('c',visited=False)

g.add_node('d',visited=False)

g.add_node('e',visited=False)

g.add_node('f',visited=False)

g.add_node('g',visited=False)

g.add_node('h',visited=False)

g.add_node('i',visited=False)

g.add_edge('a','b',weight=4)

g.add_edge('a','h',weight=8)

g.add_edge('b','a',weight=4)

g.add_edge('b','c',weight=8)

g.add_edge('b','h',weight=11)

g.add_edge('c','b',weight=8)

g.add_edge('c','d',weight=7)

g.add_edge('c','f',weight=4)

g.add_edge('c','i',weight=2)

g.add_edge('d','d',weight=7)

g.add_edge('d','e',weight=9)

g.add_edge('d','f',weight=14)

g.add_edge('e','d',weight=9)

g.add_edge('e','f',weight=10)

g.add_edge('f','c',weight=4)

g.add_edge('f','d',weight=14)

g.add_edge('f','e',weight=10)

g.add_edge('f','g',weight=2)

g.add_edge('g','f',weight=2)

g.add_edge('g','h',weight=1)

g.add_edge('g','i',weight=6)

g.add_edge('h','a',weight=8)

g.add_edge('g','b',weight=11)

g.add_edge('h','g',weight=1)

g.add_edge('h','i',weight=7)

g.add_edge('i','c',weight=2)

g.add_edge('i','g',weight=6)

g.add_edge('i','h',weight=7)

coloring_tree(g)

#include <iostream>
#include <vector>
#include <string>
#include <list>
 
#include <limits> // for numeric_limits
 
#include <set>
#include <utility> // for pair
#include <algorithm>
#include <iterator>
 
 
typedef int vertex_t;
typedef double weight_t;
 
const weight_t max_weight = std::numeric_limits<double>::infinity();
 
struct neighbor {
    vertex_t target;
    weight_t weight;
    neighbor(vertex_t arg_target, weight_t arg_weight)
        : target(arg_target), weight(arg_weight) { }
};
 
typedef std::vector<std::vector<neighbor> > adjacency_list_t;
 
 
void DijkstraComputePaths(vertex_t source,
                          const adjacency_list_t &adjacency_list,
                          std::vector<weight_t> &min_distance,
                          std::vector<vertex_t> &previous)
{
    int n = adjacency_list.size();
    min_distance.clear();
    min_distance.resize(n, max_weight);
    min_distance[source] = 0;
    previous.clear();
    previous.resize(n, -1);
    std::set<std::pair<weight_t, vertex_t> > vertex_queue;
    vertex_queue.insert(std::make_pair(min_distance[source], source));
 
    while (!vertex_queue.empty()) 
    {
        weight_t dist = vertex_queue.begin()->first;
        vertex_t u = vertex_queue.begin()->second;
        vertex_queue.erase(vertex_queue.begin());
 
        // Visit each edge exiting u
	const std::vector<neighbor> &neighbors = adjacency_list[u];
        for (std::vector<neighbor>::const_iterator neighbor_iter = neighbors.begin();
             neighbor_iter != neighbors.end();
             neighbor_iter++)
        {
            vertex_t v = neighbor_iter->target;
            weight_t weight = neighbor_iter->weight;
            weight_t distance_through_u = dist + weight;
	    if (distance_through_u < min_distance[v]) {
	        vertex_queue.erase(std::make_pair(min_distance[v], v));
 
	        min_distance[v] = distance_through_u;
	        previous[v] = u;
	        vertex_queue.insert(std::make_pair(min_distance[v], v));
 
	    }
 
        }
    }
}
 
 
std::list<vertex_t> DijkstraGetShortestPathTo(
    vertex_t vertex, const std::vector<vertex_t> &previous)
{
    std::list<vertex_t> path;
    for ( ; vertex != -1; vertex = previous[vertex])
        path.push_front(vertex);
    return path;
}
 
 
int main()
{
    adjacency_list_t adjacency_list(9);
    adjacency_list[0].push_back(neighbor(1, 4));
    adjacency_list[0].push_back(neighbor(7, 8));

    adjacency_list[1].push_back(neighbor(0, 4));
    adjacency_list[1].push_back(neighbor(2, 8));
    adjacency_list[1].push_back(neighbor(7, 11));

    adjacency_list[2].push_back(neighbor(1, 8));
    adjacency_list[2].push_back(neighbor(3, 7));
    adjacency_list[2].push_back(neighbor(5, 4));
    adjacency_list[2].push_back(neighbor(8, 2));

    adjacency_list[3].push_back(neighbor(3, 7));
    adjacency_list[3].push_back(neighbor(4, 9));
    adjacency_list[3].push_back(neighbor(5, 14));


    adjacency_list[4].push_back(neighbor(3, 9));
    adjacency_list[4].push_back(neighbor(5, 10));
    
    adjacency_list[5].push_back(neighbor(2, 4));
    adjacency_list[5].push_back(neighbor(3, 14));
    adjacency_list[5].push_back(neighbor(4, 10));
    adjacency_list[5].push_back(neighbor(6, 2));

    adjacency_list[6].push_back(neighbor(5, 2));
    adjacency_list[6].push_back(neighbor(7, 1)); 
    adjacency_list[6].push_back(neighbor(8, 6)); 

    
    adjacency_list[7].push_back(neighbor(0, 9));
    adjacency_list[7].push_back(neighbor(1, 9));    
    adjacency_list[7].push_back(neighbor(6, 9));    
    adjacency_list[7].push_back(neighbor(8, 9));    
    

    adjacency_list[8].push_back(neighbor(2, 2));
    adjacency_list[8].push_back(neighbor(6, 6));
    adjacency_list[8].push_back(neighbor(7, 7));

    std::vector<weight_t> min_distance;
    std::vector<vertex_t> previous;
    DijkstraComputePaths(0, adjacency_list, min_distance, previous);
    std::cout << "Distance from 0 to 5: " << min_distance[5] << std::endl;
    std::list<vertex_t> path = DijkstraGetShortestPathTo(5, previous);
    std::cout << "Path : ";
    std::copy(path.begin(), path.end(), std::ostream_iterator<vertex_t>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

#include <iostream>

#include <vector>

#include <string>

#include <list>

#include <limits> // for numeric_limits

#include <set>

#include <utility> // for pair

#include <algorithm>

#include <iterator>

typedef int vertex_t;

typedef double weight_t;

const weight_t max_weight = std::numeric_limits<double>::infinity();

struct neighbor {

vertex_t target;

weight_t weight;

neighbor(vertex_t arg_target, weight_t arg_weight)

: target(arg_target), weight(arg_weight) { }

};

typedef std::vector<std::vector<neighbor> > adjacency_list_t;

void DijkstraComputePaths(vertex_t source,

const adjacency_list_t &adjacency_list,

std::vector<weight_t> &min_distance,

std::vector<vertex_t> &previous)

{

int n = adjacency_list.size();

min_distance.clear();

min_distance.resize(n, max_weight);

min_distance[source] = 0;

previous.clear();

previous.resize(n, -1);

std::set<std::pair<weight_t, vertex_t> > vertex_queue;

vertex_queue.insert(std::make_pair(min_distance[source], source));

while (!vertex_queue.empty())

{

weight_t dist = vertex_queue.begin()->first;

vertex_t u = vertex_queue.begin()->second;

vertex_queue.erase(vertex_queue.begin());

// Visit each edge exiting u

const std::vector<neighbor> &neighbors = adjacency_list[u];

for (std::vector<neighbor>::const_iterator neighbor_iter = neighbors.begin();

neighbor_iter != neighbors.end();

neighbor_iter++)

{

vertex_t v = neighbor_iter->target;

weight_t weight = neighbor_iter->weight;

weight_t distance_through_u = dist + weight;

if (distance_through_u < min_distance[v]) {

vertex_queue.erase(std::make_pair(min_distance[v], v));

min_distance[v] = distance_through_u;

previous[v] = u;

vertex_queue.insert(std::make_pair(min_distance[v], v));

}

std::list<vertex_t> DijkstraGetShortestPathTo(

vertex_t vertex, const std::vector<vertex_t> &previous)

{

std::list<vertex_t> path;

for ( ; vertex != -1; vertex = previous[vertex])

path.push_front(vertex);

return path;

}

int main()

{

adjacency_list_t adjacency_list(9);

adjacency_list[0].push_back(neighbor(1, 4));

adjacency_list[0].push_back(neighbor(7, 8));

adjacency_list[1].push_back(neighbor(0, 4));

adjacency_list[1].push_back(neighbor(2, 8));

adjacency_list[1].push_back(neighbor(7, 11));

adjacency_list[2].push_back(neighbor(1, 8));

adjacency_list[2].push_back(neighbor(3, 7));

adjacency_list[2].push_back(neighbor(5, 4));

adjacency_list[2].push_back(neighbor(8, 2));

adjacency_list[3].push_back(neighbor(3, 7));

adjacency_list[3].push_back(neighbor(4, 9));

adjacency_list[3].push_back(neighbor(5, 14));

adjacency_list[4].push_back(neighbor(3, 9));

adjacency_list[4].push_back(neighbor(5, 10));

adjacency_list[5].push_back(neighbor(2, 4));

adjacency_list[5].push_back(neighbor(3, 14));

adjacency_list[5].push_back(neighbor(4, 10));

adjacency_list[5].push_back(neighbor(6, 2));

adjacency_list[6].push_back(neighbor(5, 2));

adjacency_list[6].push_back(neighbor(7, 1));

adjacency_list[6].push_back(neighbor(8, 6));

adjacency_list[7].push_back(neighbor(0, 9));

adjacency_list[7].push_back(neighbor(1, 9));

adjacency_list[7].push_back(neighbor(6, 9));

adjacency_list[7].push_back(neighbor(8, 9));

adjacency_list[8].push_back(neighbor(2, 2));

adjacency_list[8].push_back(neighbor(6, 6));

adjacency_list[8].push_back(neighbor(7, 7));

std::vector<weight_t> min_distance;

std::vector<vertex_t> previous;

DijkstraComputePaths(0, adjacency_list, min_distance, previous);

std::cout << "Distance from 0 to 5: " << min_distance[5] << std::endl;

std::list<vertex_t> path = DijkstraGetShortestPathTo(5, previous);

std::cout << "Path : ";

std::copy(path.begin(), path.end(), std::ostream_iterator<vertex_t>(std::cout, " "));

std::cout << std::endl;

return 0;

}

Distance from 0 to 5: 16
Path : 0 1 2 5

1 2	Distance from 0 to 5: 16 Path : 0 1 2 5

ref [1]

Standard Exception Handler in C++ and Custom Exception Handler with Examples

Leave a reply

Exception handling

try
{
    some code
}
catch (Exception e)
{
    throw e;
}
catch (...)//... will catch any exception
{
    throw;
}

try

{

some code

}

catch (Exception e)

{

throw e;

}

catch (...)//... will catch any exception

{

throw;

}

C++ Standard Exceptions

1)std::bad_alloc
2)std::bad_cast
3)std::bad_exception
4)std::bad_typeid
5)std::logic_error
	5-1)std::domain_error: exception thrown when a mathematically invalid domain is used.
	5-2)std::invalid_argument
	5-3)std::length_error
	5-4)std::out_of_range
6)std::runtime_error: An exception that theoretically cannot be detected by reading the code.
	6-1)std::overflow_error :
    The only standard library components that
    throw std::overflow_error are std::bitset::to_ulong and std::bitset::to_ullong.
	6-2)std::underflow_error
	6-3)std::range_error

1)std::bad_alloc

2)std::bad_cast

3)std::bad_exception

4)std::bad_typeid

5)std::logic_error

5-1)std::domain_error: exception thrown when a mathematically invalid domain is used.

5-2)std::invalid_argument

5-3)std::length_error

5-4)std::out_of_range

6)std::runtime_error: An exception that theoretically cannot be detected by reading the code.

6-1)std::overflow_error :

The only standard library components that

throw std::overflow_error are std::bitset::to_ulong and std::bitset::to_ullong.

6-2)std::underflow_error

6-3)std::range_error

List of Example

struct Foo { virtual ~Foo() {} };
struct Bar { virtual ~Bar() {} };


void bad_allocExample()
{
    try
    {
        while (true)
        {
            new int[100000000ul];
        }
    } catch (const std::bad_alloc& e)
    {
        std::cout << "Allocation failed: " << e.what() << '\n';
    }
}


void bad_castExample()
{
    Bar b;
    try
    {
        Foo& f = dynamic_cast<Foo&>(b);
    } catch(const std::bad_cast& e)
    {
        std::cout << e.what() << '\n';
    }
}


void bad_typeidExample()
{
    Foo* p = nullptr;
    try
    {
        std::cout << typeid(*p).name() << '\n';
    } catch(const std::bad_typeid& e) {
        std::cout << e.what() << '\n';
    }
}


void logical_ErrorExample()
{
    int amount, available;
    amount=10;
    available=9;
    if(amount>available)
    {
        throw std::logic_error("Error");
    }
    catch ( std::exception &e )
    {
      std::cerr << "Caught: " << e.what( ) << std::endl;
      std::cerr << "Type: " << typeid( e ).name( ) << std::endl;
    };
}

void domain_errorExample()
{
    try
    {
        const double x = std::acos(2.0);
        std::cout << x << '\n';
    }
    catch (std::domain_error& e)
    {
        std::cout << e.what() << '\n';
    }
    catch (...)
    {
        std::cout << "Something unexpected happened" << '\n';
    }

}

void invalid_argumentExample()
{
    try
    {
    // binary wrongly represented by char X
        std::bitset<32> bitset(std::string("0101001X01010110000"));
    }
    catch (std::exception &err)
    {
        std::cerr<<"Caught "<<err.what()<<std::endl;
        std::cerr<<"Type "<<typeid(err).name()<<std::endl;
    }
}

void length_errorExample()
{
    try
    {
        // vector throws a length_error if resized above max_size
        std::vector<int> myvector;
        myvector.resize(myvector.max_size()+1);
    }
    catch (const std::length_error& le)
    {
        std::cerr << "Length error: " << le.what() << '\n';
    }
}

void out_of_rangeExample()
{
    std::vector<int> myvector(10);
    try
    {
        myvector.at(20)=100;      // vector::at throws an out-of-range
    }
    catch (const std::out_of_range& oor)
    {
        std::cerr << "Out of Range error: " << oor.what() << '\n';
    }
}

void overflow_errorExample()
{
    try
    {
        std::bitset<100> bitset;
        bitset[99] = 1;
        bitset[0] = 1;
        // to_ulong(), converts a bitset object to the integer that would generate the sequence of bits
        unsigned long Test = bitset.to_ulong();
    }
    catch(std::exception &err)
    {
        std::cerr<<"Caught "<<err.what()<<std::endl;
        std::cerr<<"Type "<<typeid(err).name()<<std::endl;
    }
}


void range_errorExample()
{
    try
    {
       throw std::range_error( "The range is in error!" );
    }
    catch (std::range_error &e)
    {
       std::cerr << "Caught: " << e.what( ) << std::endl;
       std::cerr << "Type: " << typeid( e ).name( ) << std::endl;
    }
}


//Defining your exceptions

struct CustomException : public std::exception
{
   const char * what () const throw ()
   {
      return "CustomException happened";
   }
};

void customExceptionExample()
{
    try
    {
        throw CustomException();
    } catch(CustomException& e)
    {
        std::cout << "CustomException caught" << std::endl;
        std::cout << e.what() << std::endl;
    } catch(std::exception& e)
    {
    //Other errors
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

struct Foo { virtual ~Foo() {} };

struct Bar { virtual ~Bar() {} };

void bad_allocExample()

{

try

{

while (true)

{

new int[100000000ul];

}

} catch (const std::bad_alloc& e)

{

std::cout << "Allocation failed: " << e.what() << '\n';

}

void bad_castExample()

{

Bar b;

try

{

Foo& f = dynamic_cast<Foo&>(b);

} catch(const std::bad_cast& e)

{

std::cout << e.what() << '\n';

}

void bad_typeidExample()

{

Foo* p = nullptr;

try

{

std::cout << typeid(*p).name() << '\n';

} catch(const std::bad_typeid& e) {

std::cout << e.what() << '\n';

}

void logical_ErrorExample()

{

int amount, available;

amount=10;

available=9;

if(amount>available)

{

throw std::logic_error("Error");

}

catch ( std::exception &e )

{

std::cerr << "Caught: " << e.what( ) << std::endl;

std::cerr << "Type: " << typeid( e ).name( ) << std::endl;

};

}

void domain_errorExample()

{

try

{

const double x = std::acos(2.0);

std::cout << x << '\n';

}

catch (std::domain_error& e)

{

std::cout << e.what() << '\n';

}

catch (...)

{

std::cout << "Something unexpected happened" << '\n';

}

void invalid_argumentExample()

{

try

{

// binary wrongly represented by char X

std::bitset<32> bitset(std::string("0101001X01010110000"));

}

catch (std::exception &err)

{

std::cerr<<"Caught "<<err.what()<<std::endl;

std::cerr<<"Type "<<typeid(err).name()<<std::endl;

}

void length_errorExample()

{

try

{

// vector throws a length_error if resized above max_size

std::vector<int> myvector;

myvector.resize(myvector.max_size()+1);

}

catch (const std::length_error& le)

{

std::cerr << "Length error: " << le.what() << '\n';

}

void out_of_rangeExample()

{

std::vector<int> myvector(10);

try

{

myvector.at(20)=100; // vector::at throws an out-of-range

}

catch (const std::out_of_range& oor)

{

std::cerr << "Out of Range error: " << oor.what() << '\n';

}

void overflow_errorExample()

{

try

{

std::bitset<100> bitset;

bitset[99] = 1;

bitset[0] = 1;

// to_ulong(), converts a bitset object to the integer that would generate the sequence of bits

unsigned long Test = bitset.to_ulong();

}

catch(std::exception &err)

{

std::cerr<<"Caught "<<err.what()<<std::endl;

std::cerr<<"Type "<<typeid(err).name()<<std::endl;

}

void range_errorExample()

{

try

{

throw std::range_error( "The range is in error!" );

}

catch (std::range_error &e)

{

std::cerr << "Caught: " << e.what( ) << std::endl;

std::cerr << "Type: " << typeid( e ).name( ) << std::endl;

}

//Defining your exceptions

struct CustomException : public std::exception

{

const char * what () const throw ()

{

return "CustomException happened";

}

};

void customExceptionExample()

{

try

{

throw CustomException();

} catch(CustomException& e)

{

std::cout << "CustomException caught" << std::endl;

std::cout << e.what() << std::endl;

} catch(std::exception& e)

{

//Other errors

}

Robotics with ROS

Newton’s method Explained

3D Point to 3D Point Pose Estimation Explained

Perspective N Points (PnP) Explained

Understanding the Mathematics behind Gradient Descent

Motion Model for Robots Explained

Bézier Curve Equation Explained

Kinematic Equation for Differential Drive Explained

Example of Test Driven Development with C++ and Google Test

Step 1, Write enough failing Test Code

Step 2, Write Production code to pass the failing tests.

Step 3, Refactor the production code

Dijkstra’s algorithm with C++

Standard Exception Handler in C++ and Custom Exception Handler with Examples

Exception handling

C++ Standard Exceptions

List of Example