c

g++ Helloworld.cpp -o Hello/g++ Helloworld.cpp

// 位与 两个位都为1时，结果才为1
&

// 位或 两个位都为0时，结果才为0
|

// 位异或 两个位相同位0，相异为1
^

// 位取反 0变1，1变0
~

// 二进制左移，各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。
<<

// 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。
>>

//c风格
#include <stdio.h>
int main( ) {
 
   char str[100];
   int i;
 
   printf( "Enter a value :");
   //在读取字符串时，只要遇到一个空格，scanf() 就会停止读取，所以 "this is test" 对 scanf() 来说是三个字符串。
   scanf("%s %d", str, &i);
 
   printf( "\nYou entered: %s %d ", str, i);
   printf("\n");
   return 0;
}

//c++输出输出流
#include <iostream>

using namespace std;

int main( ){
   char name[50];
 
   cout << "请输入您的名称： ";
   cin >> name;
   cout << "您的名称是： " << name << endl;
 
}

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

//为了访问结构的成员，我们使用成员访问运算符（.）
int main( )
{
   Books Book1;        // 定义结构体类型 Books 的变量 Book1
   Books Book2;        // 定义结构体类型 Books 的变量 Book2
 
   // Book1 详述
   strcpy( Book1.title, "C++ 教程");
   strcpy( Book1.author, "Runoob"); 
   strcpy( Book1.subject, "编程语言");
   Book1.book_id = 12345;
 
   // Book2 详述
   strcpy( Book2.title, "CSS 教程");
   strcpy( Book2.author, "Runoob");
   strcpy( Book2.subject, "前端技术");
   Book2.book_id = 12346;
 
   // 输出 Book1 信息
   cout << "第一本书标题 : " << Book1.title <<endl;
   cout << "第一本书作者 : " << Book1.author <<endl;
   cout << "第一本书类目 : " << Book1.subject <<endl;
   cout << "第一本书 ID : " << Book1.book_id <<endl;
 
   // 输出 Book2 信息
   cout << "第二本书标题 : " << Book2.title <<endl;
   cout << "第二本书作者 : " << Book2.author <<endl;
   cout << "第二本书类目 : " << Book2.subject <<endl;
   cout << "第二本书 ID : " << Book2.book_id <<endl;
 
   return 0;
}

//指向结构体的指
struct Books *struct_pointer;
//结构变量的地址
struct_pointer = &Book1;
//指向该结构的指针访问结构的成员，需要使用->运算符
struct_pointer->title;

char 1字节 -128～127 或 0～255
int 4字节
short int 2字节
float 4字节
double 8字节

//等价于null, c++11
nullptr

//转换为string型, c++17
to_string()

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

//decltype 类型推导
int i = 4;
decltype(i) a; //推导结果为int。a的类型为int。

min = INT_MIN;
max = INT_MAX;

printf("ASCII value = %d, Character = %c\n", ch , ch );

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

//字符串生成
string s("1a2b3c4d5e6f7g8h9i1a2b3c4d5e6f7g8ha9i");
string::size_type position;


//find 函数 返回jk 在s 中的下标位置 
position = s.find("jk");
//如果没找到，返回一个特别的标志c++中用npos表示
if (position != s.npos){
	cout << "position is : " << position << endl;
}else{
	cout << "Not found the flag" + flag;
}

//字符串结束符号
\0

//atoi字符串转换成整型数的
using namespace std;

int main(){  
    string str ="123";
    //.c_str()函数返回一个指向正规C字符串的指针常量, 内容与本string串相同
    int num = atoi(str.c_str());
    cout<<num<<endl;
    getchar();
    return 0;
}

// 重载 + 运算符，用于把两个 Box 对象相加
Box operator+(const Box& b)
{
	Box box;
	box.length = this->length + b.length;
	box.breadth = this->breadth + b.breadth;
	box.height = this->height + b.height;
	return box;
}

// 导入
#include <vector>

//get vector size
nums.size()

//init
//声明一个int型向量a
vector<int> a ;
//声明一个初始大小为10的向量
vector<int> a(10) ;
//声明一个初始大小为10且初始值都为1的向量
vector<int> a(10, 1) ;
//声明二维数组， 并初始化
vector<vector<int>> a(n, vector<int>(n, 0));
//声明并用向量a初始化向量b
vector<int> b(a) ;
//将a向量中从第0个到第2个(共3个)作为向量b的初始值
vector<int> b(a.begin(), a.begin()+3) ;

//对其中部分元素进行输入
cin >>a[2];
cin >>a[5];
cin >>a[6];

//返回空的vector
return {};

//全部输出
int i ;
for(i=0; i<a.size(); i++) cout<<a[i]<<" " ;

//遍历器
//全部输出
vector<int>::iterator t ;
for(t=a.begin(); t!=a.end(); t++)
    cout<<*t<<" " ;

//begin( ) 函数返回一个指向向量开头的迭代器。
a.begin();
//end( ) 函数返回一个指向向量末尾的迭代器。
a.end();

//cbegin()和cend()是C++11新增的，它们返回一个const的迭代器，不能用于修改元素
a.cbegin()
a.cend()

//获取向量中的元素个数
a.size()
//判断向量是否为空
a.empty()
//清空向量中的元素
a.clear()
//将1000插入到向量a的起始位置前
a.insert(a.begin(), 1000);
//将1000分别插入到向量元素位置的0-2处
a.insert(a.begin(), 3, 1000);
//a向量与b向量进行交换
b.swap(a);
//删除最后一个元素
v5.pop_back();
//加入一个元素并把它放在最后
v5.push_back(6);
//删除第四个元素
v5.erase(v5.begin() + 3);



//创建一个10*5的int型二维
vector< vector<int> > b(10, vector<int>(5)); 

//C++11 container initializer
vector<string> vs={"first", "second", "third"};

#include<iostream>
#include<map>
#include<string>
 
using namespace std;
 
int main(){
    // 构造函数
    map<string, int> dict;
    // 插入数据的三种方式
    dict.insert(pair<string,int>("apple",2));
    dict.insert(map<string, int>::value_type("orange",3));
    dict["banana"] = 6;
 
    // 判断是否有元素
    if(dict.empty())
        cout<<"该字典无元素"<<endl;
    else
        cout<<"该字典共有"<<dict.size()<<"个元素"<<endl;
 
    // 遍历
    map<string, int>::iterator iter;
    for(iter=dict.begin();iter!=dict.end();iter++)
        cout<<iter->first<<ends<<iter->second<<endl;
 
    // 查找
    if((iter=dict.find("banana"))!=dict.end()) //  返回一个迭代器指向键值为key的元素，如果没找到就返回end()
        cout<<"已找到banana,其value为"<<iter->second<<"."<<endl;
    else
        cout<<"未找到banana."<<endl;
 
    if(dict.count("watermelon")==0) // 返回键值等于key的元素的个数
        cout<<"watermelon不存在"<<endl;
    else
        cout<<"watermelon存在"<<endl;
    return 0;
}

#include<string>  
#include<iostream>  
#include<unordered_map>
using namespace std;  
  
int main()
{
    unordered_map<string, int>  dict; // 声明unordered_map对象

    // 插入数据的三种方式
    dict.insert(pair<string,int>("apple",2));
    dict.insert(unordered_map<string, int>::value_type("orange",3));
    dict["banana"] = 6;

    // Create an unordered_map of three strings (that map to strings)
    std::unordered_map<std::string, std::string> u = {
        {"RED","#FF0000"},
        {"GREEN","#00FF00"},
        {"BLUE","#0000FF"}
    };

    // 判断是否有元素
    if(dict.empty())
        cout<<"该字典无元素"<<endl;
    else
        cout<<"该字典共有"<<dict.size()<<"个元素"<<endl;
    // 遍历
    unordered_map<string, int>::iterator iter;
    for(iter=dict.begin();iter!=dict.end();iter++)
        cout<<iter->first<<ends<<iter->second<<endl;
    // 查找
    if(dict.count("boluo")==0)
        cout<<"can't find boluo!"<<endl;
    else
        cout<<"find boluo!"<<endl;
    if((iter=dict.find("banana"))!=dict.end())
        cout<<"banana="<<iter->second<<endl;
    else
        cout<<"can't find boluo!"<<endl;
    return 0;
}

using namespace std; 
  
int main() 
{ 
    // declaring set for storing string data-type 
    unordered_set<string> stringSet; 
  
    // inserting various string, same string will be stored 
    // once in set 
    stringSet.insert("code"); 
    stringSet.insert("in"); 
    stringSet.insert("c++"); 
    stringSet.insert("is"); 
    stringSet.insert("fast"); 
  
    string key = "slow"; 
  
    //find returns end iterator if key is not found, 
    //else it returns iterator to that key 
    if (stringSet.find(key) == stringSet.end()) 
        cout << key << " not found\n\n"; 
    else
        cout << "Found " << key << endl << endl; 
  
    key = "c++"; 
    if (stringSet.find(key) == stringSet.end()) 
        cout << key << " not found\n"; 
    else
        cout << "Found " << key << endl; 
  
    // now iterating over whole set and printing its 
    // content 
    cout << "\nAll elements : "; 
    unordered_set<string> :: iterator itr; 
    for (itr = stringSet.begin(); itr != stringSet.end(); itr++) 
        cout << (*itr) << endl; 
}

slow not found

Found c++

All elements : 
is
fast
c++
in
code

//创建空集合,不包含任何元素
set c:
//以op为排序准则，产生一个空的set
set c(op)
//复制c2中的元素到c1中
set c1(c2)
//复制[first, last)之间元素构成新集合
set c(const value_type *first, const value_type* last)
//以op为排序准则，复制[first, last)之间元素构成新集合。
set c(const value_type *first, const value_type* last,op)
//销毁所有元素，释放内存
c.~set()

//返回容器元素个数
int size() const
//判断容器是否为空，若返回true，表明容器已空
bool empty() const

//插入元素x
pair<iterator,bool> insert( x)
//在迭代器it处插入元素x
iterator insert(iterator it,x)
//插入[first, last)之间元素
void insert(const value_type *first,const value_type *last)
//删除迭代器指针it处元素
iterator erase(iterator it)
//删除[first, last)之间元素
iterator erase(iterator first,iterator last)
//删除元素值等于key的元素
size_type erase(const Key& key)

//返回首元素的迭代器指针
iterator begin()
//返回尾元素的迭代器指针
riterator end()

//转换0～5下标的元素
std::reverse(a,a+5);

cout<<"min_element: "<<*min_element(myvec.begin(),myvec.end())<<endl;
cout<<"max_element: "<<*max_element(myvec.begin(),myvec.end())<<endl;

// string::substr
#include <iostream>
#include <string>
int main (){
    std::string str="We think in generalities, but we live in details.";
    // (quoting Alfred N. Whitehead)
    std::string str2 = str.substr (3,5); // "think"
    std::size_t pos = str.find("live"); // position of "live" in str
    std::string str3 = str.substr (pos); // get from "live" to the end
    std::cout << str2 << ' ' << str3 << '\n';
    return 0;
}

//创建一个空的deque
deque<Elem> c
//复制一个deque
deque<Elem> c1(c2) 
//创建一个deque，含有n个数据，数据均已缺省构造产生。
deque<Elem> c(n) 
//创建一个含有n个elem拷贝的deque。
deque<Elem> c(n, elem) 
//创建一个以[beg;end)区间的deque。
deque<Elem> c(beg,end) 
//销毁所有数据，释放内存。
~deque<Elem>()

//返回指向第一个元素的迭代器
c.begin()
//返回指向最后一个元素下一个位置的迭代器
c.end()

//在末尾位置插入元素
c.push_back(num)
//删除末尾位置的元素
c.pop_back()
//在开头位置插入元素
c.push_front(num)
//删除开头位置的元素
c.pop_front()

//在pos位置插入元素num
c.insert(pos,num)
//删除pos位置的元素
c.erase(pos)

stack <int> s; 
s.push(10); 
s.push(30); 
s.push(20); 
s.push(5); 
s.push(1); 

# 1 5 20 30 10
showstack(s);

# 5
s.size();
# 1
s.top();

s.pop;
# 5 20 30 10
showstack(s);

#include <queue>
queue<int> q1;

//返回最后一个元素
q1.back()

//如果队列空则返回真
q1.empty()

//返回第一个元素
q1.front()

//删除第一个元素
q1.pop() 

//在末尾加入一个元素
q1.push()

//返回队列中元素的个数
q1.size()

//The pair container is a simple container defined in <utility> header consisting of two data elements or objects.
pair (data_type1, data_type2) Pair_name;

//CPP program to illustrate pair STL
#include <iostream>
#include <utility>
using namespace std;

int main()
{
    pair <int, char> PAIR1 ;

    PAIR1.first = 100;
    PAIR1.second = 'G' ;

    cout << PAIR1.first << " " ;
    cout << PAIR1.second << endl ;

    return 0;
}

// sort algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector

bool myfunction (int i,int j) { return (i<j); }

struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;

int main () {
  int myints[] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33

  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33

  // using function as comp
  std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)

  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)

  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

#include<iostream>
#include<queue>
using namespace std;
 
int main(){
	priority_queue<int> p;
	p.push(1);
	p.push(2);
	p.push(8);
	p.push(5);
	p.push(43);
	for(int i=0;i<5;i++){
		cout<<p.top()<<endl;
		p.pop();
	}

	//emplace 最大的作用是避免产生不必要的临时变量
	std::vector<Foo> v;
	// 没有临时变量产生
	v.emplace(someIterator, 42, 3.1416);
	return 0;
}

   // accumulate函数的第一个功能，求和
   int total;
   total = accumulate ( v1.begin ( ) , v1.end ( ) , 0 );

   cout << "整数从1到20的和为: " 
        << total << "." << endl;

for (int num : nums) {
  if (ones > n / 2 || zeros > n / 2) break;
  if ((num & (1 << i)) != 0) ++ones;
  else ++zeros;
}

//字符串拼接
void main(){
    string s1 = "alan";
    string s2 = "xiho";

    //alanxiho
    string s3 = s1 + s2;

    string s4 = " wahaha";

    s3.append(s4);

    //alanxiho wahaha
    cout << s3 << endl;

    system("pause");
}

//string长度
string s = "c plus plus";
int len = s.length();
cout<<len<<endl;

#include <string>
using namespace std;

//string遍历
void main(){
    string s1 = "abcdefg";

    //1、数组方式
    cout << "数组方式:" << endl;
    for (int i = 0; i < s1.length(); i++){
        cout <<s1[i] << endl;

    }

    //2、迭代方式
    cout << "迭代方式:" << endl;
    for (string::iterator it = s1.begin(); it != s1.end(); it++){

        cout<<*it<< endl;

    }

    system("pause");
}

#include <iostream>
#include <cstring>
 
using namespace std;
 
int main ()
{
   char str1[11] = "Hello";
   char str2[11] = "World";
   char str3[11];
   int  len ;
 
   // 复制 str1 到 str3
   strcpy( str3, str1);
   cout << "strcpy( str3, str1) : " << str3 << endl;
 
   // 连接 str1 和 str2
   strcat( str1, str2);
   cout << "strcat( str1, str2): " << str1 << endl;
 
   // 连接后，str1 的总长度
   len = strlen(str1);
   cout << "strlen(str1) : " << len << endl;
 
   return 0;
}

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度
 
      // 成员函数声明
      double getVolume(void);
      void setLength( double len );
      void setBreadth( double bre );
      void setHeight( double hei );
      Box();   // 这是构造函数声明
      ~Box();  // 这是析构函数声明
};
 
// 成员函数定义
double Box::getVolume(void)
{
    return length * breadth * height;
}
 
void Box::setLength( double len )
{
    length = len;
}
 
void Box::setBreadth( double bre )
{
    breadth = bre;
}
 
void Box::setHeight( double hei )
{
    height = hei;
}
 
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // box 2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // box 1 的体积
   volume = Box1.getVolume();
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 2 的体积
   volume = Box2.getVolume();
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}

Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}
//上面的语法等同于如下语法：
Line::Line( double len)
{
    length = len;
    cout << "Object is being created, length = " << len << endl;
}

[capture](parameters)->return-type{body}

[](int x, int y){ return x < y ; }

//无返回值
[capture](parameters){body}
[]{ ++global_x; } 

//指定返回值类型
[](int x, int y) -> int { int z = x + y; return z + x; }

//C++变量传递有传值和传引用的区别
[]      // 沒有定义任何变量。使用未定义变量会引发错误。
[x, &y] // x以传值方式传入（默认），y以引用方式传入。
[&]     // 任何被使用到的外部变量都隐式地以引用方式加以引用。
[=]     // 任何被使用到的外部变量都隐式地以传值方式加以引用。
[&, x]  // x显式地以传值方式加以引用。其余变量以引用方式加以引用。
[=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。

//在一段内存块中填充某一个给定的值，常用于较大的对结构体和数组的清零操作。
char str[10];
str[9] = 'w';
memset(str,97,9);
//输出：a a a a a a a a a w

double x=8,  y=2;
double z;
z=pow(x,y);

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。
模板是创建泛型类或函数的蓝图或公式。

template <class type> ret-type func-name(parameter list)
{
   // 函数的主体
}

#include <iostream>
#include <string>
 
using namespace std;
 
template <typename T>
inline T const& Max (T const& a, T const& b) 
{ 
    return a < b ? b:a; 
} 
int main ()
{
 
    int i = 39;
    int j = 20;
    cout << "Max(i, j): " << Max(i, j) << endl; 
 
    double f1 = 13.5; 
    double f2 = 20.7; 
    cout << "Max(f1, f2): " << Max(f1, f2) << endl; 
 
    string s1 = "Hello"; 
    string s2 = "World"; 
    cout << "Max(s1, s2): " << Max(s1, s2) << endl; 
 
   return 0;
}

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
 
using namespace std;
 
template <class T>
class Stack { 
  private: 
    vector<T> elems;     // 元素 
 
  public: 
    void push(T const&);  // 入栈
    void pop();               // 出栈
    T top() const;            // 返回栈顶元素
    bool empty() const{       // 如果为空则返回真。
        return elems.empty(); 
    } 
}; 
 
template <class T>
void Stack<T>::push (T const& elem) 
{ 
    // 追加传入元素的副本
    elems.push_back(elem);    
} 
 
template <class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // 删除最后一个元素
    elems.pop_back();         
} 
 
template <class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // 返回最后一个元素的副本 
    return elems.back();      
} 
 
int main() 
{ 
    try { 
        Stack<int>         intStack;  // int 类型的栈 
        Stack<string> stringStack;    // string 类型的栈 
 
        // 操作 int 类型的栈 
        intStack.push(7); 
        cout << intStack.top() <<endl; 
 
        // 操作 string 类型的栈 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; 
        stringStack.pop(); 
        stringStack.pop(); 
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}