** C++ Misc 
*** Data Types Sizes 

File: [[file:src/dataTypeSizes.cpp][file:src/dataTypeSizes.cpp]]

#+BEGIN_SRC cpp :tangle src/dataTypeSizes.cpp 
/**   File:      dataTypeSizes.cpp 
      Objective: Show C/C++ primitive data types sizes.      

 */

#include <iostream>
#include <limits>

using namespace std;


int main(){
  // 8 bits / 1 byte numeric types
  //---------------------------------------------------
  int charMin = numeric_limits<char>::min() ;
  int charMax = numeric_limits<char>::max() ;
  
  int scharMin = numeric_limits<signed char>::min() ;
  int scharMax = numeric_limits<signed char>::max() ;

  int ucharMin = numeric_limits<unsigned char>::min() ;
  int ucharMax = numeric_limits<unsigned char>::max() ;

  int int8Min  = numeric_limits<int8_t>::min() ;
  int int8Max  = numeric_limits<int8_t>::max() ;  

  int uint8Min  = numeric_limits<uint8_t>::min() ;
  int uint8Max  = numeric_limits<uint8_t>::max() ;

  // 16 bits / 2 bytes Numeric types
  //---------------------------------------------------
  
  int shortMin  = numeric_limits<short>::min() ;
  int shortMax  = numeric_limits<short>::max() ;

  int ushortMin  = numeric_limits<unsigned short>::min() ;
  int ushortMax  = numeric_limits<unsigned short>::max() ;
  
  int int16Min  = numeric_limits<int16_t>::min() ;
  int int16Max  = numeric_limits<int16_t>::max() ;  

  int uint16Min  = numeric_limits<uint16_t>::min() ;
  int uint16Max  = numeric_limits<uint16_t>::max() ;  

  // 32 bits / 4 bytes Numeric types
  //---------------------------------------------------
    
  int intMin  = numeric_limits<int>::min() ;
  int intMax  = numeric_limits<int>::max() ;  
  
  cout << "C/C++ Data type sizes in number of bytes (1 byte = 8 bits)" << endl;

  cout << "\n1 byte / 8 bits Data types"                       << endl;
  cout <<  "------------------------------------"              << endl; 
  cout << "sizeof(char)          = " << sizeof(char)           << " min = " << charMin  << " max = " << charMax << endl; 
  cout << "sizeof(signed char)   = " << sizeof(signed char)    << " min = " << scharMin << " max = " << scharMax << endl; 
  cout << "sizeof(unsigned char) = " << sizeof(unsigned char)  << " min = " << ucharMin << " max = " << ucharMax << endl; 
  cout << "sizeof(int8_t)        = " << sizeof(int8_t)         << " min = " << int8Min  << " max = " << int8Max << endl; 
  cout << "sizeof(uint8_t)       = " << sizeof(uint8_t)        << " min = " << uint8Min << " max = " << uint8Max << endl; 
  
  cout << "\n2 bytes / 16 bits Data types"                     << endl;  
  cout <<  "------------------------------------"              << endl;   
  cout << "sizeof(short)         = " << sizeof(short)          << " min = " << shortMin  << " max = " << shortMax  << endl; 
  cout << "sizeof(usigned short) = " << sizeof(unsigned short) << " min = " << ushortMin << " max = " << ushortMax << endl; 
  cout << "sizeof(int16_t)       = " << sizeof(int16_t)        << " min = " << int16Min  << " max = " << int16Max  << endl;  
  cout << "sizeof(uint16_t)      = " << sizeof(uint16_t)       << " min = " << uint16Min << " max = " << uint16Max << endl;  
  
  cout << "\n4 bytes / 32 bits Data types"                    << endl;  
  cout <<  "------------------------------------"             << endl;   
  cout << "sizeof(int)           = " << sizeof(int)           << " min = " << intMin << " max = " << intMax << endl;  
  cout << "sizeof(int32_t)       = " << sizeof(int32_t)       << endl;
  cout << "sizeof(int64_t)       = " << sizeof(int64_t)       << endl;
  
  cout << "sizeof(float)         = " << sizeof(float)         << endl;  
    cout << "\n8 bytes / 64 bits Data types"                    << endl;  
  cout <<  "------------------------------------"             << endl;    
  cout << "sizeof(long)          = " << sizeof(long)          << endl;
  cout << "sizeof(long long)     = " << sizeof(long long)     << endl;    
  cout << "sizeof(double)        = " << sizeof(double)        << endl;  
  
  return 0;
}

#+END_SRC

Running:

#+BEGIN_SRC sh
$ g++ dataTypeSizes.cpp -o dataTypeSizes.bin && ./dataTypeSizes.bin
C/C++ Data type sizes in number of bytes (1 byte = 8 bits)

1 byte / 8 bits Data types
------------------------------------
sizeof(char)          = 1 min = -128 max = 127
sizeof(signed char)   = 1 min = -128 max = 127
sizeof(unsigned char) = 1 min = 0 max = 255
sizeof(int8_t)        = 1 min = -128 max = 127
sizeof(uint8_t)       = 1 min = 0 max = 255

2 bytes / 16 bits Data types
------------------------------------
sizeof(short)         = 2 min = -32768 max = 32767
sizeof(usigned short) = 2 min = 0 max = 65535
sizeof(int16_t)       = 2 min = -32768 max = 32767
sizeof(uint16_t)      = 2 min = 0 max = 65535

4 bytes / 32 bits Data types
------------------------------------
sizeof(int)           = 4 min = -2147483648 max = 2147483647
sizeof(int32_t)       = 4
sizeof(int64_t)       = 8
sizeof(float)         = 4

8 bytes / 64 bits Data types
------------------------------------
sizeof(long)          = 8
sizeof(long long)     = 8
sizeof(double)        = 8

#+END_SRC

*** Simple assertion testing - file testing1.cpp
   :PROPERTIES:
   :ID:       106aed05-30af-44c1-b3c1-a360b025ac09
   :END:

 - file:src/testing1.cpp - Unit test example cpp files - [[https://drive.google.com/viewerng/viewer?url%3Dhttp://users.csc.calpoly.edu/~djanzen/tdl/AutomatedUnitTesting.pdf][Automated Unit Testing for CPP]]


#+BEGIN_SRC cpp :tangle src/testing.cpp
#include <cassert>

int sum(int min, int max){
  return min + max;
}

int main()
{
  assert(sum(0, 2)  == 3);
  assert(sum(-2, 2) == 0);
  assert(sum(3, 7) == 25);

  return 0;

}
#+END_SRC


#+BEGIN_SRC sh
$ ./testing.bin
testing.bin: testing1.cpp:9: int main(): Assertion `sum(0, 2) == 3' failed.
Aborted
#+END_SRC

*** Assertion in CPP - file assert.cpp                    :assert:test:check:
   :PROPERTIES:
   :ID:       6796c748-6658-49b1-be2e-ad444af89229
   :END:


File: file:src/assert.cpp

#+BEGIN_SRC cpp :tangle src/assert.cpp
// Description: Assertion demonstration in C++.
// Author:      Caio Rodrigues
// File:        assert.cpp
// Compile: g++ assert.cpp -o assert.bin
//

#include <cassert>    // Assertion
#include <iostream>   // Standard library

int main (int argc, char * argv[]) {

  // Check argc and exit if not enough arguments are provided to avoid segmentation fault.
  //
  if (argc != 2){
    std::cout << "Usage: ./" << argv[0] << "[n]" << std::endl;
    std::cout << "where [n] is a number > 0. If n * n != 25 the assertion fails." << std::endl;

    exit(0); // exit(1) - Return status code 1 - Indicating failure.
  }

  int i = atoi(argv[1]);
  int j = i * i ;

  assert (j == 25);

  std::cout << "continuing" << std::endl;

  exit(0); // exit(0) - Return status code 0 - Indicating success.
}

#+END_SRC

This file demonstrate assertion in C++. If the square of input
argument is not 25 it throws an assertion error.

Compile:

#+BEGIN_SRC sh
$ g++ assert.cpp -o assert.bin
#+END_SRC

*Running:*

No arguments - print help

#+BEGIN_SRC sh
./assert.bin
Usage: ././assert.bin[n]
where [n] is a number > 0. If n * n != 25 the assertion fails.
#+END_SRC

Passing 4 as argument.

#+BEGIN_SRC sh
./assert.bin 4
assert.bin: assert.cpp:24: int main(int, char**): Assertion `j == 25' failed.
#+END_SRC

Passing 10 as argument

#+BEGIN_SRC sh
./assert.bin 10
assert.bin: assert.cpp:24: int main(int, char**): Assertion `j == 25' failed.

#+END_SRC

Passing 5 as argument. 5 * 5 == 25. Ok. The assertion doesn't fail.

#+BEGIN_SRC sh
./assert.bin 5
continuing
#+END_SRC
*** Parse number                                     :atoi:atof:parse:number:
   :PROPERTIES:
   :ID:       170ef7e0-8f02-4bc3-afb6-38b2ee8810d6
   :END:

Shows how to parse number with atoi, atof and so on.

File: file:src/numberParse.cpp

#+BEGIN_SRC cpp :tangle src/numberParse.cpp
// Description: atoi, atof, strtol demonstration.
// Note: Convert string to integer, double and long integer.
// Tags: atoi, atof, strtol
//

#include <cassert>
#include <iostream>

using namespace std;

int main (){

  cout << "\nAtoi - parse int 32 bits" << endl;

  cout << "atoi(\"2342\")    = " << atoi("2342")  << endl;
  cout << "atoi(\"-2323\")   = " << atoi("-2323") << endl;
  cout << "atoi(\"failed\")  = " << atoi("failed") << endl;
  cout << "atoi(\"12xy346\") = " << atoi("12xy346") << endl;

  cout << "\nAtof - parse float/double" << endl;

  cout <<  "atof(\"100.23\")              = "  << atof("100.23") << endl;
  cout <<  "atof(\"-20.015e3\")           = "  << atof("-20.015e3") << endl;
  cout <<  "atof(\"100.134354blablah\")   = "  << atof("100.134354blablah") << endl;
  cout <<  "atof(\"failed0.3123garbage\") = "  << atof("failed0.3123garbage") << endl;

  return 0;
}
#+END_SRC

Running:

#+BEGIN_SRC sh
./g++ numberParse.cpp -o numberParse.bin && ./numberParse.bin

Atoi - parse int 32 bits
atoi("2342")    = 2342
atoi("-2323")   = -2323
atoi("failed")  = 0
atoi("12xy346") = 12

Atof - parse float/double
atof("100.23")              = 100.23
atof("-20.015e3")           = -20015
atof("100.134354blablah")   = 100.134
atof("failed0.3123garbage") = 0
#+END_SRC
*** C++ Functions with Arrays (C-style)
    :PROPERTIES:
    :ID:       a89d5099-af3a-4034-8331-628fe59a0eb7
    :END:

  - [[file:src/arraysFun.cpp][file:src/arraysFun.cpp]]

#+BEGIN_SRC cpp :tangle src/arraysFun.cpp
#include <iostream>  // Basic IO functions
#include <cmath>     // C-math functions such as sqrt, pow ...
#include <cassert>   // Assertions

using namespace std;

// Function prototypes
//---------------------------------//

double scalarProduct   (double [], double [], int);
double vectorSum       (double [], int);
double vectorNorm      (double [], int);
void   printVectorVert (double xs[], int size);

//  Main function
//-------------------------------

int main()
{
  int size = 4 ;
  double v1[] = {1.0, 2.0, 3.0, 4.0} ;
  double v2[] = {3.0, 4.0, 5.0, 6.0} ;

  cout << "\n\nVector v1 = " << endl ;
  printVectorVert(v1, size);

  cout << "\n\nVector v2 = " << endl ;
  printVectorVert(v2, size);

  cout << "\n\nScalar product is = " << scalarProduct(v1, v2, size) << endl;

  cout << "Vector v1 sum is  = " << vectorSum(v1, size) << endl;

  cout << "Vector v2 Norm is = " << vectorNorm(v1, size) << endl;

  assert(scalarProduct(v1, v2, size) == 50.0);

  return 0 ; // Return 0 as status code.
}

//  Functions Implementations
// -------------------------------- //

double scalarProduct(double xs[], double ys[], int size){
  double sum = 0.0;

    for (int i = 0; i <= size -1; i++){
      sum = sum + xs[i] * ys[i];
    }
  return sum;
}

double vectorSum(double xs[], int size){
  double sum = 0.0 ;

  for (int i = 0; i <= size - 1; i++){
    sum = sum + xs[i];
  }
  return sum;
}


double vectorNorm(double xs[], int size){
  double sum = 0.0 ;

  for (int i = 0; i <= size - 1; i++){
    sum = sum + xs[i] * xs[i];
  }
  return sqrt(sum);
}


void printVectorVert(double xs[], int size){
  for (int i = 0; i <= size -1; i++){
    cout << "v[" << i << "] = " << xs[i] << endl ;
  }
}
#+END_SRC

Program output:

#+BEGIN_SRC sh
g++ arraysFun.cpp -o arraysFun.bin && ./arraysFun.bin


Vector v1 =
v[0] = 1
v[1] = 2
v[2] = 3
v[3] = 4


Vector v2 =
v[0] = 3
v[1] = 4
v[2] = 5
v[3] = 6


Scalar product is = 50
Vector v1 sum is  = 10
Vector v2 Norm is = 5.47723


#+END_SRC

*** C++ Concrete Data Types (Classes)
    :PROPERTIES:
    :ID:       4699b19e-1282-44bc-9cf3-a5ad8cd6c6cd
    :END:
**** Class with operator overload (vector2D)
     :PROPERTIES:
     :ID:       4bcee82a-e2d8-48c6-b09e-8253b54958ea
     :END:

 - File: [[file:src/cppVector2D.cpp][file:src/cppVector2D.cpp]]

#+BEGIN_SRC cpp :tangle src/cppVector2D.cpp
#include <iostream>
#include <cmath>

using namespace std;

class vector2D
{
private:
  // Private members
  double x;
  double y;
  
public:
  
  // Class constructors 
  vector2D();
  vector2D(double vX, double vY);

  // Getters
  double getX() const;
  double getY() const;

  void print() const;

  void move(double dx, double dy);

  void setPos(double vX, double vY);

  //-- Operators (Binary Functions/ Class members) -- //

  vector2D operator+ (vector2D B);
  vector2D operator- (vector2D B);
  
  vector2D operator* (double factor);
  vector2D operator/ (double factor);
  
};

vector2D::vector2D() {
  x = 0.0;
  y = 0.0; 
}

vector2D::vector2D(double vX, double vY){
  x = vX;
  y = vY;
}

double vector2D::getX() const{
  return x;
}

double vector2D::getY() const{
  return y;
}


void vector2D::move(double dx, double dy){
  x = x + dx;
  y = y + dy;
}


void vector2D::setPos(double vX, double vY)
{
  x = vX;
  y = vY;
}

void vector2D::print() const
{
  cout << "Vector2D (X = " << x << ", Y = " << y << ")" << endl;
}

vector2D vector2D::operator + (vector2D B){
  vector2D res;
  res.x = x + B.x;
  res.y = y + B.y;
  return res;
}


vector2D vector2D::operator - (vector2D B){
  vector2D res;
  res.x = x - B.x;
  res.y = y - B.y;
  return res;
}


vector2D vector2D::operator * (double factor){
  vector2D res;
  res.x = x * factor; 
  res.y = y * factor;
  return res;
}


vector2D vector2D::operator / (double factor){
  vector2D res;
  res.x = x / factor; 
  res.y = y / factor;
  return res;
}



int main(){

  vector2D vA = vector2D();
  vector2D vB = vector2D(10.23, -8.63);

  vA.print();
  vA.move(2.0, 3.0);
  vA.print();
  
  vB.print();
  vB.move(2.0, 3.0);
  vB.print();

  cout << "\n(1) Vc = vA + vB = " << endl;
  vector2D vC = vA + vB;
  vC.print();

  cout << "\n(2) Vc = vA + vB = " << endl;  
  (vA + vB).print();

  cout << "\n(3) vB * 3.0 = " << endl;
  (vB * 3.0).print();
  
  cout << "\n(4) (vA + vB) / 2.0 = " << endl;
  vector2D vD = (vB + vB) / 2.0 ;
  vD.print();


  // ----------- Pointer Tests ------------------ // 

  vector2D * vp ;

  vp = & vB ;  // Assign pointer to address of vector vB.

  cout  << "\n\nPointer address = " << vp << endl ;


  cout << "\nvp->print()   = " << endl;
  vp->print();

  cout << "\n(*vp).print() = " << endl;  
  (*vp).print();

  cout << "\nvector2D m = *vp; m.print(); = " << endl;  
  vector2D m = *vp;  
  m.print();
  
  return 0;
}

#+END_SRC

Running:

#+BEGIN_SRC sh1
$ g++ cppVector2D.cpp -o cppVector2D.bin && ./cppVector2D.bin
Vector2D (X = 0, Y = 0)
Vector2D (X = 2, Y = 3)
Vector2D (X = 10.23, Y = -8.63)
Vector2D (X = 12.23, Y = -5.63)

(1) Vc = vA + vB = 
Vector2D (X = 14.23, Y = -2.63)

(2) Vc = vA + vB = 
Vector2D (X = 14.23, Y = -2.63)

(3) vB * 3.0 = 
Vector2D (X = 36.69, Y = -16.89)

(4) (vA + vB) / 2.0 = 
Vector2D (X = 12.23, Y = -5.63)


Pointer address = 0x7fffa50cb390

vp->print()   = 
Vector2D (X = 12.23, Y = -5.63)

(*vp).print() = 
Vector2D (X = 12.23, Y = -5.63)

vector2D m = *vp; m.print(); = 
Vector2D (X = 12.23, Y = -5.63)


#+END_SRC

*** C++ STL Vectors Containers 
**** Overview 

*C++ Arrays Drawbacks*

 - The size of array is fixed or constant.

 - Passing an array as parameter is cumbersome since the array and its
   size must be passed.

 - There is no way to insert elements at the beggining or at the end.

 - It is not possible to return an array from a function.

 - It requires manual memory management and allocation what is error
   prone.

*Vectors*

 - C++ Vectors are a class in C++.

 - Size of vectors can grow or shrink during execution.

 - A vector stores its size, therefore a it doesn't need to be passed
   as function argument.

 - It provides random access. Vector elements can accessed by its
   indexes like C/C++ arrays.

 - Vectors can be returned from functions.

*Vectors X Arrays Declaration*

C/C++ Arrays

#+BEGIN_SRC cpp
const int VECTOR_SIZE = 10;
double xs[VECTOR_SIZE];
#+END_SRC

C/C++ STL Vector

#+BEGIN_SRC cpp
const int VECTOR_SIZE = 10
vector<double> xs;
#+END_SRC

**** Vector Class

*Import vector class*

Add at the top of file. - =#include <vector>=

#+BEGIN_SRC cpp 
#include <iostream>
#include <vector>

using namespace std;
... .... ... ... ... 
#+END_SRC

**** Example 

File: [[file:src/cppStlVector.cpp][file:src/cppStlVector.cpp]]


#+BEGIN_SRC cpp :tangle src/cppStlVector.cpp
  #include <iostream>
  #include <vector>
  #include <cmath>
  #include <string>

  using namespace std;

  /// Pass the vectors by value. It copies the vectors, so passing by
  //  reference does not copies the vectors and it is more efficient.
  //
  vector<double> sumVectors1(vector<double> xs, vector<double> ys){
    vector<double> zs(xs.size());
    
    for (int i = 0; i < xs.size(); i++){
      zs.at(i) = xs.at(i) + ys.at(i);
    }

    return zs;
  }

  vector<double> sumVectors2(vector<double> &xs, vector<double> &ys){
    vector<double> zs(xs.size());
    
    for (int i = 0; i < xs.size(); i++){
      zs.at(i) = xs.at(i) + ys.at(i);
    }

    return zs;
  }


  void printVector1(string name, vector<double> xs){
    cout << name << " = [ "; 
    
    for (int i = 0; i < xs.size(); i++){
      cout << xs.at(i) << " " ;
    }

    cout << "]" << endl;
  }

  void printVector2(string name, vector<double> &xs){
    cout << name << " = [ "; 
    
    for (int i = 0; i < xs.size(); i++){
      cout << xs.at(i) << " " ;
    }

    cout << "]" << endl;
  }

  void printVectorWithIterator(string name, vector<double> &xs){
    cout << name << " = [ "; 
    
    for (vector<double>::iterator i = xs.begin(); i != xs.end(); ++i){
      cout << *i << " " ;    
    }

    cout << "]" << endl;
    
  }


  // Returns the sum of all vector elements.
  double vectorSum(vector<double> &xs){
    double sum = 0;
    
    for (int i = 0; i < xs.size(); i++){
      sum = sum + xs.at(i);
    }

    return sum;
  }

  // Returns the product of all vectors elements.
  double vectorProd(vector<double> &xs){
    double prod = 1.0;
    
    for (int i = 0; i < xs.size(); i++){
      prod = prod + xs.at(i);
    }

    return prod;
  }

  double vectorNorm(vector<double> &xs){
    double sum = 1.0;
    double x   = 0.0;
    
    for (int i = 0; i < xs.size(); i++){
      x = xs.at(i);
      sum = sum + x * x;
    }

    return sqrt(sum);
  }


  double vectorAverage(vector<double> &xs){
    double sum = 1.0;
    
    for (int i = 0; i < xs.size(); i++){    
      sum = sum + xs.at(i);
    }

    return sum / xs.size();
  }


  void vectorAnalytics(string name, vector<double> &xs){
    cout << "\n\nAnalytic for vector " << name     << endl;
    cout << "----------------------------------- " << endl;
    printVector2(name, xs);
    cout << "size    = " << xs.size()         << endl;
    cout << "average = " << vectorAverage(xs) << endl;
    cout << "sum     = " << vectorSum(xs)     << endl;
    cout << "product = " << vectorProd(xs)    << endl;
    cout << "norm    = " << vectorNorm(xs)    << endl;
    
  }


  int main(){
    int size = 6;

    //  Vector initialized from a double array.
    vector<double> xs({1, 2, 3, 5.5, 10.8, 4.5});

    // Vector initialized with all elements set to 0.0
    vector<double> ys(6);

    // Vector intialized with all elements set to 4.0
    vector<double> zs(6, 4.0);

    // Vector with 0 elements.
    vector<double> ks;

    printVector1("xs", xs);

    printVector1("ys", ys);

    printVector2("zs", zs);

    printVectorWithIterator("Print Vector with iteractor - xs", xs);
    
    cout << "xs.size()      = " << xs.size()  << endl ;
    cout << "xs.at(3)       = " << xs.at(3)   << endl ;    
    cout << "xs.at(0)       = " << xs.at(0)   << endl ;
    cout << "xs.at(5)       = " << xs.at(5)   << endl ;      
    cout << "vectorSum(xs)  = " << vectorSum(xs) << endl;
    cout << "vectorNorm(xs) = " << vectorNorm(xs) << endl;
    
    printVector1("sumVectors1(xs, zs) = xs + zs", sumVectors1(xs, zs));
    printVector1("sumVectors2(xs, zs) = xs + zs", sumVectors2(xs, zs));

    cout << "Clear vector xs -> "  ;
    xs.clear();
    printVector2("xs", xs);

    ks.push_back(4.0);
    ks.push_back(5.0);
    ks.push_back(3.0);
    ks.push_back(6.0);
    ks.push_back(7.0);
    ks.push_back(9.3);
    printVector2("ks", ks);
    
    vectorAnalytics("ks", ks);
    
    return 0;
  }

#+END_SRC


Running:

#+BEGIN_SRC sh
$ g++ cppStlVector.cpp -o cppStlVector.bin && ./cppStlVector.bin
xs = [ 1 2 3 5.5 10.8 4.5 ]
ys = [ 0 0 0 0 0 0 ]
zs = [ 4 4 4 4 4 4 ]
Print Vector with iteractor - xs = [ 1 2 3 5.5 10.8 4.5 ]
xs.size()      = 6
xs.at(3)       = 5.5
xs.at(0)       = 1
xs.at(5)       = 4.5
vectorSum(xs)  = 26.8
vectorNorm(xs) = 13.4959
sumVectors1(xs, zs) = xs + zs = [ 5 6 7 9.5 14.8 8.5 ]
sumVectors2(xs, zs) = xs + zs = [ 5 6 7 9.5 14.8 8.5 ]
Clear vector xs -> xs = [ ]
ks = [ 4 5 3 6 7 9.3 ]


Analytic for vector ks
----------------------------------- 
ks = [ 4 5 3 6 7 9.3 ]
size    = 6
average = 5.88333
sum     = 34.3
product = 35.3
norm    = 14.9161


#+END_SRC

** Linux - Only
*** Show glibc - file glibc-version.c 

 - file:src/glibc-version.c

Source:

#+BEGIN_SRC c
  /*
  Description: Show glibc Version. 
  OS:          Linux only 

  Compile with:

   $ gcc glibc-version.c -o glibc-version.bin && ./glibc-version.bin 
   glibc version: 2.24

   ,*/
  #include <stdio.h>
  #include <stdlib.h>
  #include <gnu/libc-version.h>

  int main(int argc, char *argv[]) {
    printf("glibc version: %s\n", gnu_get_libc_version());
  }

#+END_SRC

Compile:

#+BEGIN_SRC sh
 gcc glibc-version.c -o glibc-version.bin 
#+END_SRC

Run:

#+BEGIN_SRC sh 
  $ ./src/glibc-version.bin 
  glibc version: 2.24
#+END_SRC
