CPP / C++ Notes

#include <iostream>
#include <string>

int main(){
    std::cout << "Hello world user" << "\n";
    std::cout << "Enter your name: ";
    std::string name;
    std::getline(std::cin, name);
    std::cout << "Be welcome to C++ land: " << name << "\n";

    // Wait user type a single character
    std::cout << "\n" << "Type RETURN to exit";
    // Read a character from standard input (console)
    std::cin.get();

    // Status code
    return 0;
}

std::cout << "\n" << "Type RETURN to exit";
// Read a character from standard input (console)
std::cin.get();

return 0;

// Same as 0 
return EXIT_SUCCESS; 

return EXIT_FAILURE;

$ clang++ minimal-program1.cpp -o minimal-program1.bin -g -std=c++14 -Wall 

$ g++ minimal-program1.cpp -o minimal-program1.bin -g -std=c++14 -Wall  

$ g++ minimal-program1.cpp -o minimal-program1.exe -g -std=c++14 -Wall 
// On Console (cmd.exe)
$ minimal-program1.exe 
// Or 

$ ./minimal-program1.bin 
Hello world user
Enter your name: Somebody else
Be welcome to C++ land: Somebody else

Type RETURN to exit

{VARIABLE} = {CONDITION} ? {RETURN-IF-TRUE} : {RETURN-IF-FASLE};

>> true ? "true" : "false"
(const char *) "true"
>> false ? "true" : "false"
(const char *) "false"

>> int x;
>> x = true ? 10 : 25
(int) 10
>> x
(int) 10

>> x = false ? 10 : 25
(int) 25
>>
>>

>> std::string s;
>> x = 10;
>> s = (x < 15) ? "true" : "false"
"true"

>> x = 100;
>> s = (x < 15) ? "true" : "false"
"false"
>>

void printMonth1(int n){
    const char nl = '\n';
     switch(n){
        case 1:  std::cout << "JAN" << nl; break;
        case 2:  std::cout << "FEB" << nl; break;
        case 3:  std::cout << "MAR" << nl; break;
        case 4:  std::cout << "APR" << nl; break;           
        case 5:  std::cout << "MAY" << nl; break;
        case 6:  std::cout << "JUN" << nl; break;
        case 7:  std::cout << "JUL" << nl; break;
        case 8:  std::cout << "AUG" << nl; break;
        case 9:  std::cout << "SEP" << nl; break;
        case 10: std::cout << "OCT" << nl; break;
        case 11: std::cout << "NOV" << nl; break;
        case 12: std::cout << "DEC" << nl; break;
        default: std::cout << "Error: invalid month." << nl; break;
     }
}

>> printMonth1(1)
JAN
>> printMonth1(2)
FEB
>> printMonth1(12)
DEC
>> printMonth1(100)
Error: invalid month.
>> printMonth1(-1)
Error: invalid month.
>> 

void printMonth2(int n){
    const char nl = '\n';
     switch(n){
        case 1:  std::cout << "JAN" << nl; break;
        case 2:  std::cout << "FEB" << nl; break;
        case 3:  std::cout << "MAR" << nl; break;
        case 4:  std::cout << "APR" << nl; break;           
        case 5:  std::cout << "MAY" << nl; break;
        case 6:  std::cout << "JUN" << nl; break;
        case 7:  std::cout << "JUL" << nl; break;
        case 8:  std::cout << "AUG" << nl; break;
        case 9:  std::cout << "SEP" << nl; break;
        case 10: std::cout << "OCT" << nl; break;
        case 11: std::cout << "NOV" << nl; break;
        case 12: std::cout << "DEC" << nl; break;
     }
     std::cout << "Error: invalid month." << nl; break;
}

#include <std::string>
std::string getMonth(int n){
     switch(n){
         case 1:  return "JAN";
         case 2:  return "FEB";
         case 3:  return "MAR";
         case 4:  return "APR";
         case 5:  return "MAY";
         case 6:  return "JUN";
         case 7:  return "JUL";
         case 8:  return "AUG";
         case 9:  return "SEP";
         case 10: return "OCT";
         case 11: return "NOV";
         case 12: return "DEC";
         default:
                 throw std::domain_error("Error: invalid month");
     }
}

std::string month;    
month = getMonth(1);
std::cout << "Month = " << month << "\n";     
month = getMonth(4);
std::cout << "Month = " << month << "\n";    

try{
    month = getMonth(100);
    std::cout << "Month = " << month << "\n";    
} catch(const std::domain_error& ex){
    std::cout << "An error has happened = " << ex.what() << "\n";
}

Month = JAN
Month = APR
An error has happened = Error: invalid month

#include <string>

int getDayOfWeekNum(const std::string& weekDay){
    if(weekDay == "Sun") return 1;
    if(weekDay == "Mon") return 2;
    if(weekDay == "Tue") return 3;
    if(weekDay == "Wed") return 4;
    if(weekDay == "Thu") return 5;
    if(weekDay == "Fri") return 6;
    if(weekDay == "Sat") return 7;
    return -1;
}

>> getDayOfWeekNum("Sun")
(int) 1
>> getDayOfWeekNum("Tue")
(int) 3
>> getDayOfWeekNum("Fri")
(int) 6
>> getDayOfWeekNum("")
(int) -1
>> getDayOfWeekNum("Error")
(int) -1
>> 

#include <string>
#include <map>

int getDayOfWeekNum2(const std::string& weekDay){
    static auto week_table = std::map<std::string, int> {
       {"Sun", 1}, {"Mon", 2}, {"Tue", 3}, {"Wed", 4},
       {"Thu", 5}, {"Fri", 6}, {"Sat", 7}
    };
    if(week_table.find(weekDay) != week_table.end())
       return week_table[weekDay];  
    return -1;
}

>> getDayOfWeekNum2("Sun")
(int) 1
>> getDayOfWeekNum2("Mon")
(int) 2
>> getDayOfWeekNum2("Monasd")
(int) -1
>> 

#include <iostream>

>> for(int x = 0; x < 5; x++) {
       std::cout << " x = " << x << "\n";
   }
 x = 0
 x = 1
 x = 2
 x = 3
 x = 4

>> for(double x = -10.0; x <= 10.0; x += 2.5) {
        std::cout << " x = " << x << "\n";
   }
 x = -10
 x = -7.5
 x = -5
 x = -2.5
 x = 0
 x = 2.5
 x = 5
 x = 7.5
 x = 10
>>

>> for(;;){ std::puts(" It is an infinity loop"); }
 It is an infinity loop
 It is an infinity loop
 It is an infinity loop
 It is an infinity loop
 .,.. ... ... ...

#include <iostream>
#include <cstdio>

>> n = 0
(int) 0

>> while(n < 5){  std::cout << "n = " << n++ << "\n"; }
n = 0
n = 1
n = 2
n = 3
n = 4

>> int j = 0;
>> while(j++ < 5){  std::cout << "j = " << j << "\n"; }
j = 1
j = 2
j = 3
j = 4
j = 5
>> j = 0
(int) 0

>> while(++j < 5){  std::cout << "j = " << j << "\n"; }
j = 1
j = 2
j = 3
j = 4
>>

>> while(true){ std::cout << " It is an infinity loop" << "\n";}
It is an infinity loop
It is an infinity loop
It is an infinity loop
... ... ... ..

int z = -10;

// Single line
>> do{ std::cout << " z = " << z << "\n"; z++; } while(z < 0)
 z = -10
 z = -9
 z = -8
 z = -7
 z = -6
 z = -5
 z = -4
 z = -3
 z = -2
 z = -1
>>

// Multiple Lines
do{
    std::cout << " z = " << z << "\n";
    z++;
} while(z < 0)

// C++ header equivalent to C <stdio.h>
#include <cstdio>
#include <string>

// Print to STDOUT (cout)
>> std::puts(" => System programming.");
 => System programming.

// Print to STDERR (cerr)
>> std::perror(" => Print error and logging to stderr.");
 => Print error and logging to stderr.: No such file or directory


// Write to file (disk file, or pseudo-files such as stderr or stdout)
// U-nix where C comes from see everything as files. 

>> std::fputs("Hello world\n", stdout);
Hello world
>> std::fputs("Hello world\n", stderr);
Hello world
>> 

>> std::string text;
>> text = "Hello world C-IO facilities\n";

// Failure => Cannot print C++ string, only const char 
>> std::puts(text);
ROOT_prompt_5:1:11: error: no viable conversion from 'std::string' ...

>> std::puts(text.c_str());
Hello world C-IO facilities

>> std::perror(text.c_str());
Hello world C-IO facilities

#include <cstdio>
#include <cmath>

>> std::printf("The value of pi is equal to: %.4f\n", M_PI);
The value of pi is equal to: 3.1416

>> std::printf("The value of pi is equal to: %.5f\n", M_PI);
The value of pi is equal to: 3.14159
>> 
>> std::fprintf(stdout, "The value of pi is equal to: %.5f\n", M_PI);
The value of pi is equal to: 3.14159
>> 
>> std::fprintf(stderr, "The value of pi is equal to: %.5f\n", M_PI);
The value of pi is equal to: 3.14159
>> 

std:string userName = "Julius Caesar";
int points = 200;

>> std::printf(" => User = '%s' ; Points = %d\n", userName.c_str(), points);
 => User = 'Julius Caesar' ; Points = 200

>> std::fprintf(stdout, " => User = '%s' ; Points = %d\n", userName.c_str(), points) 
 => User = 'Julius Caesar' ; Points = 200

>> std::fprintf(stderr, " => User = '%s' ; Points = %d\n", userName.c_str(), points) 
 => User = 'Julius Caesar' ; Points = 200
>> 

std:string userName = "Julius Caesar";
int points = 200;

>> std::printf("User = '%s' ; Points = %d\n", points, userName.c_str());
*** Break *** segmentation violation

// Expected "c-string" (const char*) but provided int
>> std::printf("%s\n", 100);
*** Break *** segmentation violation

#include <iostream> 
#include <string> 

>> double x;
>> std::cin >> x;
342.34
>> x
(double) 342.34000
>> 
>> std::cout << "Enter x: "; std::cin >> x; std::cout << " => x = " << x << "\n";
Enter x: 100
 => x = 100
>> 

>> std::string user;
>> std::cout << "Name: "; std::cin >> user; std::cout << " => user is = " << user <<Name: Julius Caesar
 => user is = Julius
>> 

>> std::string some_line;

// User types something and then hit RETURN when he is done.
>> std::cin >> some_line;
some message to compute     

// The remaining words were ignored. 
>> some_line
(std::string &) "some"
>> 

// User types something and then hit RETURN when he is done.
>> std::getline(std::cin, some_line); 
 C++ is an old cool programming language.

>> some_line
(std::string &) " C++ is an old cool programming language."
>> 

>> std::cout << " COMMAND => " ; std::getline(std::cin, some_line);
 COMMAND => go to position 200 300

>> some_line
(std::string &) "go to position 200 300"
>> 

std::string line;

// Read lines until user types something invalid or sends EOF 
// Ctlr + Z on Windows, Ctrl + D on U-nix (Linux, BSD, OSX ...)
while(std::getline(std::cin, line)){ 
  std::cout << "You typed = " << line << "\n";
}

 Caesar cypher
You typed =  Caesar cypher
 Hardening encryption 
You typed =  Hardening encryption
 Digital Signal Processors
You typed =  Digital Signal Processors
  ASICS and FPGAs custom hardware
You typed =   ASICS and FPGAs custom hardware
>> 
>> 

void runREPL(){
  std::string line;
  if(std::cin.fail()){
    std::cerr << " [INFO] Input stream failure " << "\n";
    std::cin.clear();
    std::cin.ignore();
  }
  while((std::cout << " CMD=> " << std::flush), std::getline(std::cin, line)){
    std::cout << " + Typed command was = " << line << "\n";
  }
  std::cout << "\n" << " === Finish REPL session. OK ===" << "\n";
  std::cin.clear();
}

>> runREPL()
 CMD=> Testing C++ on ROOT REPL.
 + Typed command was = Testing C++ on ROOT REPL.
 CMD=> Clang is the best compiler out there
 + Typed command was = Clang is the best compiler out there
 CMD=> Clang has the best and less cryptic error messages
 + Typed command was = Clang has the best and less cryptic error messages
 CMD=>   
 === Finish REPL session. OK ===
>> 

#include <iostream> 
#include <string> 

int         id, quantity;
double      price;
std::string name;

// Read from console
>> std::cin >> id >> name >> quantity >> price ;
2351 Cooking-oil 20 3.12

>> id
(int) 2351
>> quantity
(int) 20
>> name
(std::string &) "Cooking-oil"
>> price
(double) 3.1200000
>> 

#include <iostream>
#include <string>
#include <deque>

struct Product{
    unsigned long id;
    std::string   name;     
    double        price;
    unsigned int  quantity;
    Product(){}
};

// Or it could also be:
class Product{
public:
    unsigned long id;
    std::string   name;     
    double        price;
    unsigned int  quantity;
    Product(){}
};

Product readProductFromConsole(){
    Product p;
    std::cin >> p.id >> p.name >> p.price >> p.quantity;
    return p;
};

// Type Alias   
using Inventory = std::deque<Product>;

Inventory readInventory(){
   Inventory inv;
   std::cin.clear();
   std::cout << "Enter product ID, product Name, product Price, product Quantity." << "\n";
   std::cout << "Type CTRL+D on U-nix or CTRL+Z on Windows when you are done." << "\n";     
   while(std::cin.good() && !std::cin.eof()){
       std::cout << " => ";
       inv.push_back(readProductFromConsole());
   }
   return inv;
}                                                                          

// User types "2000 Sugar 1.45 9000" and then types RETURN when he is done.
//------------------------------------------
>> auto x = readProductFromConsole()
2000 Sugar 1.45 9000
(Product &) @0x7f16eb8fc010

>> x.id
(unsigned long) 2000

>> x.name
(std::string &) "Sugar"

>> x.price
(double) 1.4500000

>> x.quantity
(unsigned int) 9000

>> auto inventory = readInventory()
Enter product ID, product Name, product Price, product Quantity.
Type CTRL+D on U-nix or CTRL+Z on Windows when you are done.
 => 803 Cooking-oil 10.23 200
 => 2001 Sugar 2.40 500
 => 9134 Car-battery 50.0 6000
 => 8023 Milk 4.50 300 

 // Print inventory data: 
 for(const auto& prod: inventory){
     double value = prod.quantity * prod.price;
     std::cout << "Id       = " << prod.id       << "\n"
               << "Name     = " << prod.name     << "\n"
               << "Quantity = " << prod.quantity << "\n"        
               << "Price    = " << prod.price    << "\n"
               << "Value    = " << value         << "\n"
               << "----------------------------" << "\n";
 }

 //--------- Output -------------
 Id       = 803
 Name     = Cooking-oil
 Quantity = 200
 Price    = 10.23
 Value    = 2046
 ----------------------------
 Id       = 2001
 Name     = Sugar
 Quantity = 500
 Price    = 2.4
 Value    = 1200
 ----------------------------
... ... .... 

#include <iostream>
#include <string>
#include <iomanip>
#include <vector>

int main(){ 
    // Everything is initialized as zero
    double price, sum, min, max;
    std::vector<double> dataset;
    sum = 0.0;
    min = 1e10;
    max = -1e10;        

    // Print float point numbers with 2 decimal places and fixed notation 
    std::cout << std::setprecision(2) << std::fixed;
    std::cout << "Enter the prices and type CTRL+D you are done." << "\n";

    // Execute this code block while there is any error on the stream.
    // It means, the user did not type any bad input or
    //  CTRL + D (Send EOF End of File - signal)
    int n = 0;
    while(std::cin.good()){
       // (i++) Post increment i, increment variable i after it is print.
       std::cout << " => price[" << n++ << "] = ";
       // Read the price from stdin (standard input or console). 
       std::cin >> price;
       if(!std::cin.good()){
          std::cerr << " [LOG] " << "User typed invalid input. Exit loop." << "\n";
          // Force exiting the loop 
          break;
       }
       sum += price;
        dataset.push_back(price);
       if(price > max)
          max = price;
       if(price < min)
          min = price;
    }
    // Clear stream error flag 
    std::cin.clear();

    std::cout << "Sum  = " << sum       << "\n";
    std::cout << "Mean = " << (sum / n) << "\n";
    std::cout << "Min  = " << min       << "\n";
    std::cout << "Max  = " << max       << "\n";

    std::cout << "Dataset = [ ";
    for(size_t i = 0; i < dataset.size(); i++)
       std::cout << " " << dataset[i] ;
    std::cout << "] \n";

    #ifdef _WIN32 
     std::cout << "\n" << "Type RETURN to quit." << "\n";
     std::cin.clear(); 
     std::cin.ignore(10, '\n');
     // Wait for single character 
     std::cin.get();
    #endif      
    return EXIT_SUCCESS;
};

$ clang++ basic-io.cpp -o basic-io.bin -g -std=c++1z -Wall -Wextra
# OR 
$ clang++ basic-io.cpp -o basic-io.bin -g -std=c++1z -Wall -Wextra && ./basic-io.bin 

$ ./basic-io.bin 
Enter the prices and type CTRL+D you are done.
 => price[0] = 20 
 => price[1] = 21.35
 => price[2] = 51.2
 => price[3] = 40.23
 => price[4] = 60.243
 => price[5] = 78
 => price[6] =  [LOG] User typed invalid input. Exit loop.
Sum  = 271.02
Mean = 38.72
Min  = 20.00
Max  = 78.00
Dataset = [  20.00 21.35 51.20 40.23 60.24 78.00] 

$ echo "30.12 40.23 100.34 90.23 52.0" | ./basic-io.bin 
Enter the prices and type CTRL+D you are done.
 => price[0] =  => price[1] =  => price[2] =  => price[3] =  => price[4] =  => price[5] =  [LOG] User typed invalid input. Exit loop.
Sum  = 312.92
Mean = 52.15
Min  = 30.12
Max  = 100.34
Dataset = [  30.12 40.23 100.34 90.23 52.00] 

void someFunction(){
     std::puts("I am a C++ free function");
}

void someFunction(){
     std::puts("I am a C++ free function");
     return;
}

void someFunction(void){
     std::puts("I am a C++ free function");
     // return;       
}

auto someFunction(void) -> void {
     std::puts("I am a C++ free function");
     return;       
}

auto someFunction() {
     std::puts("I am a C++ free function");
     return;       
}

double someFunction(double x, int n = 4, double z = 3.5 )
{
    std::cout << "  x = "  << x
              << " ; n = " << n
              << " ; z = " << z
              << "\n";
    return x * n + 4.0 * z;
}

// OR: 
double 
someFunction(double x, int n = 4, double z = 3.5 )
{
    std::cout << "  x = "  << x
              << " ; n = " << n
              << " ; z = " << z
              << "\n";
    return x * n + 4.0 * z;
}

// Testing: Cling REPL:

>> someFunction(3.0)
  x = 3 ; n = 4 ; z = 3.5
(double) 26.000000
>> 
>> someFunction(3.0, 10, 5)
  x = 3 ; n = 10 ; z = 5
(double) 50.000000
>> 
>> someFunction(4.0)
  x = 4 ; n = 4 ; z = 3.5
(double) 30.000000
>> 

auto someFunction(double x, int n = 4, double z = 3.5) -> double
{
    std::cout << "  x = "  << x
              << " ; n = " << n
              << " ; z = " << z
              << "\n";
    return x * n + 4.0 * z;
}

>> someFunction(3.0)
  x = 3 ; n = 4 ; z = 3.5
(double) 26.000000

>> someFunction(4.0)
  x = 4 ; n = 4 ; z = 3.5
(double) 30.000000

>> someFunction(4.0, 10, 5)
  x = 4 ; n = 10 ; z = 5
(double) 60.000000
>> 

#include <iostream> 

void show(){
     std::cout << "Call Version0." << "\n";
}

void show(int x){
     std::cout << "Call Version1 with =>" << " x [int] = " << x << "\n";
}

void show(double x){
     std::cout << "Call Version2 with =>" << " x [double] = " << x << "\n";
}

void show(const char* str){
     std::cout << "Call Version2 with =>" << " x [const char*] = " << str << "\n";
}

void show(int x, double z){
     std::cout << "Call Version4 with =>"
               << " x [int] = " << x
               << " z [double] = " << z
               << "\n";
}

void show(int x, double z, const char* str){
     std::cout << "Call Version5 with =>"
               << " x [int] = " << x
               << " z [double] = " << z
               << " std [const char*] = " << str
               << "\n";
}

>> .L script.C

>> show()
Call Version0.

>> show(10)
Call Version1 with => x [int] = 10

>> show(3.1415)
Call Version2 with => x [double] = 3.1415

>> show(100, 3.1415)
Call Version4 with => x [int] = 100 z [double] = 3.1415

>> show("Function overload")
Call Version2 with => x [const char*] = Function overload

>> show(100, 3.1415, "overload")
Call Version5 with => x [int] = 100 z [double] = 3.1415 std [const char*] = overload
>> 

void counterAuto(){
   int x = 0;
   std::cout << "counter = " << x++ << "\n";
}

>> counterAuto()
counter = 0
>> counterAuto()
counter = 0
>> counterAuto()
counter = 0
>> counterAuto()
counter = 0

void counterStatic(){
   static int x = 0;
   std::cout << "counter = " << x++ << "\n";
}

>> counterStatic()
counter = 0
>> counterStatic()
counter = 1
>> counterStatic()
counter = 2
>> counterStatic()
counter = 3
>> counterStatic()
counter = 4
>> 

#include <string>

// Create an empty string 
>> std::string s1
(std::string &) ""
>> 

>> std::string s2("I am a C++ std::string")
(std::string &) "I am a C++ std::string"
>> 
>> std::string s3 = "C++ CPP 20 is coming soon!!"
(std::string &) "C++ CPP 20 is coming soon!!"
>> 

>> const char* msg = "C++ strings";
>> std::string s4 {msg}
(std::string &) "C++ strings"
>> 

>> std::string s5(10, '-')
(std::string &) "----------"
>>

>> std::string sx = "high performance computing - finite element methods";

>> sx.size()
(unsigned long) 51

>> sx.length()
(unsigned long) 51
>> 

>> std::string s;
>> s
(std::string &) ""

>> s = s + " string " + " C++ " + " Move "
(std::__cxx11::basic_string &) " string  C++  Move "

>> s
(std::string &) " string  C++  Move "
>> s += " C " + " Assembly " + " HEX "

>> std::cout << "s = '" << s << "'" << "\n";
s = ' string  C++  Move  C '
>> 

>> std::string s;
>> s
""
>> s.append("hello")
"hello"
>> s.append(" c++ ")
"hello c++ "
>> s.append(" std::string ")
"hello c++  std::string "
>> s
"hello c++  std::string "
>> 

>> std::string ss1 = "I am some string"
(std::string &) "I am some string"

>> ss1.clear()

>> ss1
(std::string &) ""

>> ss1.size()
(unsigned long) 0
>> 

>> std::string str = "Early computers were designed for number crunching.";

>> str.substr(0, 10)
"Early comp"

>> str.substr(0, 15)
"Early computers"

>> str.substr(20, str.length())
" designed for number crunching."

>> std::string pass;
>> pass
(std::string &) ""
>>
>> pass == "access"
(bool) false
>> pass = "access"
"access"
>> pass == "access"
(bool) true
>> 

>> std::string("hello") == "world"
(bool) false
>> std::string("hello") == "hello"
(bool) true
>>  

void checkPassword(const std::string& passwd){
   if(passwd == "87afx")
           std::puts("Access granted. OK.");
   else
           std::puts("Access denied. FAILURE.");
}

>> checkPassword("aa")
Access denied. FAILURE.
>> checkPassword("")
Access denied. FAILURE.
>> checkPassword("87afx")
Access granted. OK.
>> 

>> std::string ssa = "hello world string";
>> ssa
(std::string &) "hello world string"

>> std::reverse(std::begin(ssa), std::end(ssa))
>> ssa
(std::string &) "gnirts dlrow olleh"

>> std::reverse(ssa.begin(), ssa.end())
>> ssa
(std::string &) "hello world string"
>> 

void std::perror(const char*);

const char* s1 = " world ";
const char* s2 = " C++ ";
const char* s3 = " strings ";

// Compilation error:
>> std::perror( " literal1 " + "literal 2" + s1 + s2 + s3);
ROOT_prompt_4:1:27: error: invalid operands to binary expression ('const char *' and 'const char *')
std::perror( " literal1 " + "literal 2" + s1 + s2 + s3);

>> std::string text = std::string(" literal1 ") + "literal 2" + s1 + s2 + s3;
>> text
(std::string &) " literal1 literal 2 world  C++  strings "
>> 
>> std::perror(text.data())
 literal1 literal 2 world  C++  strings : No such file or directory
>> 

$ ~/opt/cling_2018-09-16_fedora27/bin/cling -std=c++17

#include <iostream>
#include <string>

[cling]$ std::string s = "concatenate " + "string"
input_line_8:2:33: error: invalid operands to binary expression ('const char *' and 'const char *')
 std::string s = "concatenate " + "string"
                 ~~~~~~~~~~~~~~ ^ ~~~~~~~~
[cling]$ 

[cling]$ "hello" == "hello"
input_line_15:2:10: warning: result of comparison against a string literal is unspecified
      (use strncmp instead) [-Wstring-compare]
 "hello" == "hello"
 ~~~~~~~ ^

$ ~/opt/cling_2018-09-16_fedora27/bin/cling -std=c++17
#include <iostream>
#include <string>
using namespace std::string_literals;

[cling]$ auto a_std_string = "this is an std::string object"s
"this is an std::string object"

[cling]$ typeid(a_std_string) == typeid(std::string)
(bool) true

// Instead of: 
[cling]$ s = std::string("concatenate ") + "string"
"concatenate string"

// The string literal operator (s) makes this code shorter:
[cling]$ auto s2 = "concatenate "s + "string"
"concatenate string"

#include <cstring>

const char* str1 = "c++ ASM";
const char* str2 = "Fortran";

[cling]$ std::string("c++ ASM") == str1
(bool) true

[cling]$ std::string("c++ ASM") == str2
(bool) false

// === Shorter alternative ===========//
[cling]$ "c++ ASM"s == str1
(bool) true
[cling]$ "c++ ASM"s == str2
(bool) false
[cling]$ 

R"(<some string ...>)"

#include <iostream>
#include <string>

int main()
{
       std::cout << std::boolalpha;
       std::cerr << std::boolalpha;

       // Raw string literals does not need escaping. 
       std::string raw1 = R"(C:\Users\nobody\tests\path)";  

       auto raw2 = std::string(R"(C:\Users\nobody\tests\path)");

       const char* raw3 = R"(
  This is a multiline 
  string
  path = C:\Users\somebody\else\docs
\n  New line char - LF (Line Feed - LF)   
\r  New line char - CR (Carriage Return)
\t  Tab char
\b  Backspace character 
       )";
       std::cout << "raw 1 = " << raw1 << std::endl;        
       std::cout << "raw 2 = "  << raw2 << std::endl;
       std::cout << "raw 3 = " << raw3 << std::endl;
       std::cout << "typeid(raw2) == typeid(std::string) ? "
                         << (typeid(raw2) == typeid(std::string))
                         << std::endl;

       return EXIT_SUCCESS;
}

$ clang++ -std=c++1z -g -Wall -Wextra cpp14-string-literals.cpp -o cpp14-string-literals.bin 
$ ./cpp14-string-literals.bin

raw 1 = C:\Users\nobody\tests\path
raw 2 = C:\Users\nobody\tests\path
raw 3 = 
   This is a multiline 
   string
   path = C:\Users\somebody\else\docs
 \n  New line char - LF (Line Feed - LF)   
 \r  New line char - CR (Carriage Return)
 \t  Tab char
 \b  Backspace character 

typeid(raw2) == typeid(std::string) ? true

std::string raw1 = "C:\\Users\\nobody\\tests\\path";    

>> std::string s = "200"
(std::string &) "200"

>> std::stoi(s)
(int) 200
>> s = "-400"
"-400"

>> s = "-400";
>> std::stoi(s)
(int) -400

// Throws exception 
>> s = "aaabb -400";
>> std::stoi(s)
Error in <TRint::HandleTermInput()>: std::invalid_argument caught: stoi
>> 

//  Read hexadecimal number 
>> s = "0xFFAB";
>> std::stoi(s, nullptr, 16)
(int) 65451
>> 

>> std::stoi("0xFF", nullptr, 16)
(int) 255
>> std::stoi("0xFFFF", nullptr, 16)
(int) 65535
>> 

>> std::string s = "21.4e3";
>> std::stod(s)
(double) 21400.000

>> s = "  .4e-6";
>> std::stod(s)
(double) 4.0000000e-07
>> 

// Throw exception and terminates program, if the exception is not caught.
>> s = "failure case  .4e-6";
>> std::stod(s)
Error in <TRint::HandleTermInput()>: std::invalid_argument caught: stod
>> 

>> s = "NAN";
>> std::stod(s)
(double) nan
>> s = "INFINITY";
>> std::stod(s)
(double) inf
>> s = "-INFINITY";
>> std::stod(s)
(double) -inf
>> 
>> s = "3.1415";
>> std::stod(s)
(double) 3.1415000
>> 

>> std::stod("1.23e3")
(double) 1230.0000
>> 

tring to_string (int val);
string to_string (long val);
string to_string (long long val);
string to_string (unsigned val);
string to_string (unsigned long val);
string to_string (unsigned long long val);
string to_string (float val);
string to_string (double val);
string to_string (long double val);

>> std::string s;
>> 
>> double x = 3.1415;

>> s = std::string("The value of x = ") + std::to_string(x)
 "The value of x = 3.141500"
>> 

>> s.clear()
>> int n = 100;
>> s = std::string("The value of n (integer) = ") + std::to_string(n)
"The value of n (integer) = 100"
>> 

#include <iostream> 
#include <iomanip>
#include <sstream>

>> std::stringstream ss;
>> 

>> std::stringstream ss;
>> ss << "Hello world" << "\n";
>> ss << "PI = " << M_PI << "\n";
>> ss << std::fixed << std::setprecision(3) << "g = " << 9.81723 << "\n";

// Get std::string from ss
>> ss.str()
"Hello world
PI = 3.14159
g = 9.817
"
>> 

>> std::string s_copy = ss.str()
(std::string &) "Hello world
PI = 3.14159
g = 9.817
"
>> 

// Clear string stream 
>> ss.str(); ss.str("");
>> ss.str()
""
>> 

void printReport(std::ostream& os){
  os << std::setprecision(3);
  os << std::fixed;
  os << std::boolalpha;
  char nl = '\n';
  os << "Report Data" << nl
     << " x = " << 23.123 << nl
     << " d = " << true   << nl
     << " z = " << M_PI   << nl;
  os.flush();
}

// Print to stdout (Standard output)
>> printReport(std::cout)
Report Data
 x = 23.123
 d = true
 z = 3.142

// Print to stderr (Standard error output)
>> printReport(std::cerr)
Report Data
 x = 23.123
 d = true
 z = 3.142
>> 

// Print to string stream 
>> std::stringstream ss;
>> printReport(ss)

>> ss.str()
 "Report Data
 x = 23.123
 d = true
 z = 3.142
"

>> std::cout << ss.str() << '\n';
Report Data
 x = 23.123
 d = true
 z = 3.142

>> printReport(ss)
>> std::cout << ss.str() << '\n';
Report Data
 x = 23.123
 d = true
 z = 3.142
Report Data
 x = 23.123
 d = true
 z = 3.142

#include <iostream>
#include <sstream>
#include <string>

std::string data = " 200 400  50.232 100 200 440";
auto ss = std::stringstream{data};
double x;

size_t i = 0;
while(!ss.eof() && !ss.fail()){
   ss >> x;
   std::cout << "x[" << i << "] = " << x << "\n";
   i++;
}

x[0] = 200
x[1] = 400
x[2] = 50.232
x[3] = 100
x[4] = 200
x[5] = 440

#include <iostream>
#include <sstream>
#include <string>

std::string line;
line =  "hex binary data always key hard narrow path bug hex";
line += " binary data path words key";

auto words = std::set<std::string>{};
auto ss = std::stringstream{line};
std::string w;
while(!ss.eof() && ss.good()){
  ss >> w;
  words.insert(w);
}

>> line
(std::string &) "hex binary data ... binary data path words key"
>> 

>> words
{ "always", "binary", "bug", "data", "hard", "hex", "key", "narrow", "path", "words" }
>> 

>> for(const auto& w: words) { std::cout << w << "\n";}
always
binary
bug
data
hard
hex
key
narrow
path
words
>> 

std::string text;
text += "C++ => FEM -> Finite Element Methods\n";
text += "C++ => High Performance Computing\n";
text += "C++ => Monte Carlo Simulations\n";

>> std::cout << text << "\n";
C++ => FEM -> Finite Element Methods
C++ => High Performance Computing
C++ => Monte Carlo Simulations

std::deque<std::string> lines;
std::string line;
// Input Stream                                                                
auto is = std::stringstream {text};

while(std::getline(is, line)) lines.emplace_back(line);

>> lines
{ "C++ => FEM -> Finite Element Methods", "C++ => High Performance Computing", "C++ => Monte Carlo Simulations" }
>> 

>> for(const auto& lin: lines) { std::cout << " + line = " << lin << "\n"; }
 + line = C++ => FEM -> Finite Element Methods
 + line = C++ => High Performance Computing
 + line = C++ => Monte Carlo Simulations
>> 

// Requires: <string> <sstream> and <iostream>                                 
auto splitLines1(const std::string& text)
  -> std::deque<std::string>
{
  auto lines = std::deque<std::string>{};
  auto line  = std::string{};
  auto is    = std::stringstream{text};
  while(std::getline(is, line))
    lines.emplace_back(line);
  return lines;
}

std::string text;
text += "=> FEM -> Finite Element Methods\n";
text += "=> High Performance Computing\n";
text += "=> Monte Carlo Simulations\n";
text += "=> Global Markets Trends\n";
text += "=> Growth forecast survery.\n";

>> for(const auto& lin: splitLines1(text)) { std::cout << " +=> " << lin << "\n"; }
 +=> => FEM -> Finite Element Methods
 +=> => High Performance Computing
 +=> => Monte Carlo Simulations
 +=> => Global Markets Trends
 +=> => Growth forecast survery.
>> 

// Read all lines from stram to container Requires: <string> <sstream>
// and <iostream>
auto splitLines2(std::istream& is) -> std::deque<std::string>
{
  std::cerr << " [INFO] L-value reference."
  auto lines = std::deque<std::string>{};
  auto line  = std::string{};
  while(std::getline(is, line))
    lines.emplace_back(line);
  return lines;
}
// Overload to work with temporary objects (R-values)
auto splitLines2(std::istream&& is) -> std::deque<std::string>
{
  std::cerr << " [INFO] R-value reference."
  auto lines = std::deque<std::string>{};
  auto line  = std::string{};
  while(std::getline(is, line))
    lines.emplace_back(line);
  return lines;
}

std::string text;
text += "=> FEM -> Finite Element Methods\n";
text += "=> High Performance Computing\n";
text += "=> Monte Carlo Simulations\n";
text += "=> Global Markets Trends\n";
text += "=> Growth forecast survery.\n";

auto ss = std::stringstream(text) ;

// Read from an L-value (object bounded to a memory location)
>> auto ss = std::stringstream(text) ;
>> auto lines = splitLines2(ss);
 [INFO] L-value reference.

>> lines2
{ "=> FEM -> Finite Element Methods", "=> High Performance Computing", ...}
>> 

// Read from an R-value (temporary object)
>> auto lines = splitLines2(std::stringstream(text));
 [INFO] R-value reference.
>> lines
 { "=> FEM -> Finite Element Methods", "=> High Performance Computing", ...}
>> 

// Read lines from file: 
>> res = splitLines2(std::ifstream("/etc/protocols"));
 [INFO] R-value reference.

>> res.size()
(unsigned long) 162
>> 

>> for(const auto& lin: res) { std::cout << " + line = " << lin << "\n";}
 + line = # /etc/protocols:
 + line = # $Id: protocols,v 1.12 2016/07/08 12:27 ovasik Exp $
 + line = #
 + line = # Internet (IP) protocols
 + line = #
 + line = # from: @(#)protocols 5.1 (Berkeley) 4/17/89
 + line = #
 + line = # Updated for NetBSD based on RFC 1340, Assigned Numbers (July 1992).
 + line = # Last IANA update included dated 2011-05-03
 + line = #
   ... ... ... ... .... 

// Types many line and then  CTRL + D (Send EOF - End Of File) when you are done.
>> auto res2 = splitLines2(std::cin);
 [INFO] L-value reference.
hello world
c++ C++11 is awesome
C++17 is amazing
C++20 RULEZ! High peformance technical computing
  Monte Carlo Methods
  High Energy Physics
  Electronic Engineering - Embedded Processors    
>> 

>> res2
 { "hello world", "c++ C++11 is awesome", "C++17 is amazing", ...}
>> 

>> auto res2copy = std::vector<std::string>(res2.begin(), res2.end())
 { "hello world", "c++ C++11 is awesome", "C++17 is amazing", ...}
>> 

>> for(const auto& lin: res2){ std::cout << " [+] line = " << lin << "\n";}
 [+] line = hello world
 [+] line = c++ C++11 is awesome
 [+] line = C++17 is amazing
 [+] line = C++20 RULEZ! High peformance technical computing
 [+] line =   Monte Carlo Methods
 [+] line =   High Energy Physics
 [+] line =   Electronic Engineering - Embedded Processors
>> 

>> std::string text = "c++ is suitable for system programming";
>> 
std::transform( text.begin(),
                text.end(),
                text.begin(),
                [](char x){ return std::toupper(x); }
                );
>> text
(std::string &) "C++ IS SUITABLE FOR SYSTEM PROGRAMMING"
>>

auto toUpper(const std::string& text) -> std::string {
  std::string out = text;
  std::transform( out.begin(),
                  out.end(),
                  out.begin(),
                  [](char x){ return std::toupper(x); }
                  );
  return out;
}

>> toUpper("c++ system programming embedded high performance")
(std::string) "C++ SYSTEM PROGRAMMING EMBEDDED HIGH PERFORMANCE"
>> 

std::string text = "c++ IS Suitable foR System proGramMing";
std::transform( text.begin(),
                text.end(),
                text.begin(),
                [](char x){ return std::tolower(x); }
                );

>> text
(std::string &) "c++ is suitable for system programming"
>> 

bool containsStr(const std::string& str, const std::string& substr){
     return str.find(substr) != std::string::npos;
}

>> containsStr("cpp plus plus cee c++ 34", "c++")
(bool) true
>> containsStr("cpp plus plus cee c++ 34", "cpp11")
(bool) false
>> containsStr("cpp plus plus cee c++ 34", "cee")
(bool) true
>> 

auto replaceStr( const std::string& text,                              
                 const std::string& rep,                                
                 const std::string& subst                               
              ) -> std::string {                                                     
  // Copy paraemter text (Invoke copy constructor)                             
  std::string out = text;                                                      
  // Find position of character matching the string                            
  size_t i = out.find(rep);                                                    
  while(i != std::string::npos){                                               
    out.replace(i, rep.size(), subst);                                         
    i = out.find(rep, i);                                                      
  }                                                                            
  return out;                                                                  
} 

>> replaceStr(" c++11 high c++future c++15 peformance cpp c++17", "c++", "")
(std::string) " 11 high future 15 peformance cpp 17"

>> replaceStr(" c++11 high c++future c++15 peformance cpp c++17", "c++", "DLang")
(std::string) " DLang11 high DLangfuture DLang15 peformance cpp DLang17"
>> 

>> replaceStr(" c++11 high c++future c++15 peformance cpp c++17", "c++", "CXX")
(std::string) " CXX11 high CXXfuture CXX15 peformance cpp CXX17"

#include <string>
#include <algorithm>

bool isNumber(const std::string& str){
  if(str == "") return false;
  return std::all_of(
             str.begin(),
             str.end(),
             [](char x){
               return std::isdigit(x);
             });
}

>> isNumber("1213")
(bool) true
>> isNumber("12x13")
(bool) false
>> isNumber("")
(bool) false
>> 

bool isNumberHex(const std::string& str){
   if(str == "") return false;
   return std::all_of(
              str.begin(),
              str.end(),
              [](char x){
                return std::isxdigit(x);
              });
 }

 >> isNumberHex("0fabcd92813")
 (bool) true
 >> 
 >> isNumberHex("0fxabcd92813")
 (bool) false
 >> isNumberHex("")
 (bool) false
 >> isNumberHex("ff")
 (bool) true
 >> isNumberHex("0xff")
 (bool) false

bool isAlphaOnly(const std::string& str){
  if(str == "") return false;
  return std::all_of(
             str.begin(),
             str.end(),
             [](char x){
               return std::isalpha(x);
             });
}

>> isAlphaOnly("helloworld")
(bool) true
>> isAlphaOnly("hello54world")
(bool) false
>> isAlphaOnly("")
(bool) false
>> isAlphaOnly("w")
(bool) true
>> isAlphaOnly("sa.ds-a")
(bool) false
>> 

>> std::string t = "key =  value";
>> size_t i = t.find("=")
(unsigned long) 4

>> t.substr(0, i)
"key "
>> 
>> t.substr(i, t.size())
"=  value"
>> t.substr(i + 1, t.size())
"  value"
>> 

#include <string>
#include <deque>

auto splitString(const std::string& str,
                 const std::string& delim
                 ) -> std::deque<std::string> {
  std::deque<std::string> xs;
  size_t i = str.find(delim);
  if(i == std::string::npos){
    xs.push_back("");
    xs.push_back("");
    return xs;
  }
  xs.push_back(str.substr(0,    i));
  xs.push_back(str.substr(i + 1, str.size()));
  return xs;
};

>> splitString("key value", "=")
(std::deque<std::string>) { "", "" }
>> splitString("key = value", "=")
(std::deque<std::string>) { "key ", " value" }
>> splitString("key  va=lue", "=")
(std::deque<std::string>) { "key  va", "lue" }
>> splitString("key  value=", "=")
(std::deque<std::string>) { "key  value", "" }
>> splitString("", "=")
(std::deque<std::string>) { "", "" }
>> splitString("key  value=", "")
(std::deque<std::string>) { "", "ey  value=" }
>> 

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip> // std::quoted in C++14

std::string s = " 200 key value \" aquoted string \"  \"next quote\"";
std::stringstream ss{s};

std::string out;

while(!ss.eof()){
  ss >> std::quoted(out);
  std::cout << "word = " << out << "\n";
}

word = 200
word = key
word = value
word =  aquoted string 
word = next quote
word = next quote

#include <iostream>
#include <sstream>
#include <string>

// Requires headers: <string> and <sstream>
auto readQuoted(std::istream& is) -> std::string {
     char ch;
     std::ostringstream so;
     if(is.eof()) return "";
     // Find first quote:
     //-------------------------------------
     do {
        ch = static_cast<char>(is.get());
     } while(is.good() && !is.eof() && std::isspace(ch));   
     //std::cout << "ch = " << ch  << "\n"; 
     if(ch != '\"'){
        so << ch;
        do {
            ch = static_cast<char>(is.get());
            so << ch;
        } while(is.good() && !is.eof() && !std::isspace(ch));
        if(is.eof()) return "";
        return so.str();
     }
     //std::cout << "ch = " << ch  << "\n"; 
     do {
        ch = static_cast<char>(is.get());
        if(ch != '\"') so << ch;
     } while(is.good() && !is.eof() && ch != '\"');
     if(is.eof()) // Did not find a matching quote.
        return "";
     //std::cout << "ch = " << ch  << "\n";
     return so.str();
}

std::string s = "  \" 200 99 888 quoted - string \" KEY \" VALUE PAIR \"  100 \" Sao Paulo City\" 4500 key ";
std::stringstream ss{s};

>>> while(ss.good()) std::cout << "quoted = " << readQuoted(ss) << "\n";
quoted =  200 99 888 quoted - string 
quoted = KEY 
quoted =  VALUE PAIR 
quoted = 100 
quoted =  Sao Paulo City
quoted = 4500 
quoted = key 
quoted = 

#include <iostream>
#include <vector>
#include <string>
#include <sstream>

std::vector<double> parseCSVRow(const std::string& line, char delim = ','){
  auto out   = std::vector<double>{};
  auto token = std::string{};
  auto ss    = std::stringstream{line};
  while(std::getline(ss, token, delim)){
    out.push_back(std::stod(token));
  }
  return out;
}

std::string raw_data = "100,   200,  400, -100.23, 60.23, 90.32";

>> parseCSVRow(raw_data)
(std::vector<double>) { 100.00000, 200.00000, 400.00000, -100.23000, 60.230000, 90.320000 }
>> auto xs = parseCSVRow(raw_data);
>> xs[0]
(double) 100.00000
>> xs[1]
(double) 200.00000
>> xs[2]
(double) 400.00000
>> xs[3]
(double) -100.23000
>> 

#include <iostream>
#include <vector>
#include <string>
#include <sstream>

template<class Type = double>
std::vector<Type> parseCSVRowGeneric(const std::string& line,
                                     char delim = ','
                                     ){
  auto out   = std::vector<Type>{};
  auto token = std::string{};
  auto ss    = std::stringstream{line};
  auto is    = std::stringstream{};
  Type value{};
  while(std::getline(ss, token, delim)){
    // Clear error flags                                                                                                                              
    is.clear();
    // Set is stream value to token                                                                                                                   
    is.str(token);
    // Extract from 'is' stream                                                                                                                       
    is >> value;
    out.push_back(value);
  }
  return out;
}

// Test data
std::string lineB = "2002.23, 434.34, 90.23, -23.23, 1e3";
std::string lineC = "100; 200; 300; 150; 500; 600";
std::string lineD = "Apple: oranges : juice beans : rice";

>> parseCSVRowGeneric(lineB)
(std::vector<double>) { 2002.2300, 434.34000, 90.230000, -23.230000, 1000.0000 }

>> parseCSVRowGeneric<>(lineB)
(std::vector<double>) { 2002.2300, 434.34000, 90.230000, -23.230000, 1000.0000 }
>> 

>> parseCSVRowGeneric<double>(lineB, ',')
(std::vector<double>) { 2002.2300, 434.34000, 90.230000, -23.230000, 1000.0000 }
>> 

>> parseCSVRowGeneric<int>(lineC, ';')
(std::vector<int>) { 100, 200, 300, 150, 500, 600 }
>> 

>> parseCSVRowGeneric<std::string>(lineD, ':')
{ "Apple", "oranges", "juice", "rice" }