Cheat sheet Question List

int a = 123;
char b = 'A';
cout<

char a = 'T';
cout<< std:string(1,a) ;  // "T"

//istringstream (use for input stream), ostringstream (use for output stream), stringstream(use for input/output both)

string str = "     bitsofjarvis  ! #  #$%   blog is gooood     ";
istringstream ss(str);
string word;
    while(ss >> word){
    cout< whereas you where waiting a write only object, you will not be happy ;-)
source : stackoverflow

string A = "I AM GOOD" , B = "YES I AM";
istringstream combined(A + " " + B);
string word;
 while (getline(combined, word, ' ')){
    cout<

tolower(c);
OR
for(auto &c : str) c = tolower(c);

str.substr(startIndex , length);

str.find("@gmail.com");

OR

 std::string str ("There are two needles in this haystack with needles.");
  std::string str2 ("needle");

  // different member versions of find in the same order as above:
  std::size_t found = str.find(str2);
  if (found!=std::string::npos)
    std::cout << "first 'needle' found at: " << found << '\n';

found=str.find("needles are small",found+1,6);
  if (found!=std::string::npos)
    std::cout << "second 'needle' found at: " << found << '\n';

  found=str.find("haystack");
  if (found!=std::string::npos)
    std::cout << "'haystack' also found at: " << found << '\n';

  found=str.find('.');
  if (found!=std::string::npos)
    std::cout << "Period found at: " << found << '\n';

  // let's replace the first needle:
  str.replace(str.find(str2),str2.length(),"preposition");
  std::cout << str << '\n';

//output : to be, or not to be: that is the question...

str.erase (10,8);   
OR
str.erase (str.begin()+5, str.end()-9);

std::string str="to be question";
  std::string str2="the ";
  std::string str3="or not to be";
  std::string::iterator it;

  // used in the same order as described above:
  str.insert(6,str2);                 // to be (the )question
  str.insert(6,str3,3,4);             // to be (not )the question
  str.insert(10,"that is cool",8);    // to be not (that is )the question
  str.insert(10,"to be ");            // to be not (to be )that is the question
  str.insert(15,1,':');               // to be not to be(:) that is the question
  it = str.insert(str.begin()+5,','); // to be(,) not to be: that is the question
  str.insert (str.end(),3,'.');       // to be, not to be: that is the question(...)
  str.insert (it+2,str3.begin(),str3.begin()+3); // (or )
  std::cout << str << '\n';
//output:to be, or not to be: that is the question...

sort(s.begin() , s.end());

string sentence = "    This   site  is Awsm     GOOOD     ";
stringstream ss(sentence);
string words;
while(ss >> words){
cout<

// stack::push/pop
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;

  for (int i=0; i<5; ++i) mystack.push(i);

  std::cout << "Popping out elements...";
  while (!mystack.empty())
  {
     std::cout << ' ' << mystack.top();
     mystack.pop();
  }
  std::cout << '\n';

  return 0;
}

// queue::push/pop
#include        // std::cin, std::cout
#include           // std::queue

int main ()
{
  std::queue myqueue;
  int myint;

  std::cout << "Please enter some integers (enter 0 to end):\n";

  do {
    std::cin >> myint;
    myqueue.push (myint);
  } while (myint);

  std::cout << "myqueue contains: ";
  while (!myqueue.empty())
  {
    std::cout << ' ' << myqueue.front();
    myqueue.pop();
  }
  std::cout << '\n';

  return 0;
}

// queue::front
#include        // std::cout
#include           // std::queue

int main ()
{
  std::queue myqueue;

  myqueue.push(77);
  myqueue.push(16);

  myqueue.front() -= myqueue.back();    // 77-16=61

  std::cout << "myqueue.front() is now " << myqueue.front() << '\n';

  return 0;
}

// queue::back
#include        // std::cout
#include           // std::queue

int main ()
{
  std::queue myqueue;

  myqueue.push(12);
  myqueue.push(75);   // this is now the back

  myqueue.back() -= myqueue.front();

  std::cout << "myqueue.back() is now " << myqueue.back() << '\n';

  return 0;
}

map<string , int> phoneNum;

phoneNum.insert( pair<string , int>("zunglee", 530-7972));

for(pair<string , int> p : phoneNum){
     cout<<"Contact Name :" <<p.first;
     cout<<"Contact number :" <<p.second;
}

//1.) COPY to vector and sort;
map<string , int> phoneNum;
..
..
..
vector<pair<string , int>> vecData;

for(auto &it : phoneNum){
      vecData.push_back(it);
}

sort(vecData.begin() ,  vecData.end() , []( pair<string,int> a , pair<string,int> b ){
   return a.second  < b.second;
});

map<string , int> phoneNum;
..
..
..
struct comp {
    template <typename T>
  
    // Comparator function
    bool operator()(const T& l,
                    const T& r) const
    {
        if (l.second != r.second) {
            return l.second < r.second;
        }
        return l.first < r.first;
    }
};

set<pair<string , int> , comp> setData(phoneNum.begin() , phoneNum.end());

map<string , int> phoneNum;
..
..
..
sortMap(phoneNum);

void sortMap(map<string , int> &M){

multimap<int, string> MM;

for (auto& it : M) {
        MM.insert({ it.second, it.first });
    }

}

//1.) Advance

eg : set<string> s ;

s.insert("zunglee");
s.insert("bits");
s.insert("of");
s.insert("jarvis");

auto first = s.begin(); // get iterator to 1st element
std::advance(first, 1);     // advance by 1
std::cout << *first;        // first element

//2.) std::next

auto it = std::next(myset.begin(), 5);
std::cout << *it;



std::advance

modifies its argument
returns nothing
works on input iterators or better (or bi-directional iterators if a negative distance is given)
std::next

leaves its argument unmodified
returns a copy of the argument, advanced by the specified amount
works on forward iterators or better (or bi-directional iterators if a negative distance is given))

priority_queue <int> pq;

    pq.push(5);
    pq.push(1);
    pq.push(10);

while (pq.empty() == false)
    {
        cout << pq.top() << " ";
        pq.pop();
    }