天天看點
傳回

C++回憶錄

文章目錄

    • 一、關于c++頭檔案
    • 二、關于文法
      • 1.用慣了python，記得每句後面加分号，且要添加類型定義
      • 2.循環
      • 3.輸入輸出
    • 三、關于string類型操作
    • 四、int類型與string類型的互換
      • 1.int—>string
      • 2.string—>int
    • 五、關于math頭檔案中的常用函數
    • 六、goto語句
    • 七、ASCII碼轉換
    • 八、進制轉換
      • 1.指定格式輸出
      • 2.使用字元串流string，stream
        • （1）8,16->10（string—>int）
        • （2）10->8,16（int—>string）
      • 3.itoa函數（int—>char）(除了2進制—>*進制)
      • 4.sprintf函數（int—>string）
      • 5.stoi函數（string—>int）(*進制—>十進制）
      • 6.bitset（int/char/string—>bitset）(十進制—>二進制)
    • 九、關于algorithm頭檔案中常用函數
      • 1.sort()函數
    • 十、類與結構體
      • 1.類
      • 2.結構體
    • 十一、向量
    • 十二、隊列
      • 1.普通隊列
      • 2.單調隊列deque
      • 3.優先隊列priority_queue（堆）
    • 十三、位運算符
    • 十四、C++中的字典——Map
      • 1.聲明
      • 2.插入操作
        • 2.1單個[]插入
        • 2.2 insert函數
      • 3.取值
      • 4.容量查詢
      • 5.疊代器
      • 6.删除交換
        • 6.1删除
        • 6.2交換
      • 7.順序比較
      • 8.查找
      • 9.操作符
      • 10.周遊map
    • 十五、數組操作
      • 1.排序
      • 2.動态數組
        • 2.1一維數組
        • 2.2二維數組
    • 十六、棧
    • 十七、setw()函數
    • 十八、set

一、關于c++頭檔案

許久沒有使用c++了，記錄一下常用的固定公式。

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<sstream>
#include<algorithm>
#include<vector>
#include<queue>
#include<math.h>
#include<bitset>
#include<map>
#include<stack>
#include<iomanip>
using namespace std;
int constant;//全局變量
int main(){}

二、關于文法

1.用慣了python，記得每句後面加分号，且要添加類型定義

2.循環 

//for循環
for(int t=0;t<10;t++){}

//while
while(true){}

//do...while
do{}while(true)

//switch..case
switch(grade){
   case 'A' :
      cout << "很棒！" << endl; 
      break;
   case 'B' :
   case 'C' :
      cout << "做得好" << endl;
      break;
   case 'D' :
      cout << "您通過了" << endl;
      break;
   case 'F' :
      cout << "最好再試一下" << endl;
      break;
   default :
      cout << "無效的成績" << endl;
}

3.輸入輸出 

//輸入
cin>>a>>b;

//輸出
cout<<"123"<<endl;

//特定輸入循環
//字元串(%s)、整數(%d)、字元(%c)、浮點數(%f)
while(scanf("%d.%d.%d...%d",&a,&b,&c,&d)!=EOF){}

//字元串輸入，以空格/回車為結束
string a,b,c,d;
while(cin>>a){} //若輸入"hello world"，循環體執行兩次
while(cin>>a>>b>>c>>d){} //輸入"hello very happy world",循環體執行一次

//字元串輸入，以行為機關
string tt;
getline(cin,tt);

三、關于string類型操作 

//定義字元串
string ss="123456789";
string s1="555";
ss.append("ss");//在字元串後面追加“ss”->"123ss"
ss.append(&ss[0]);
ss.size();//傳回int類型的字元串的長度
ss.empty();//判空
ss.substr(0,5);//獲得字元串ss中從第0位開始的長度為5的字元串
ss.substr(6);//獲得字元串ss中從第6位開始到結束的字元串
ss.find('2');//傳回值是字母在母串中的位置（下标記錄）(此處為1），如果沒有找到，那麼會傳回一個特别的标記npos（此處為ss.npos）

ss.erase(10);// 從位置pos=10處開始删除，直到結尾
ss.erase(6, 4);//從位置pos=6處開始，删除4個字元
ss.erase(ss.begin()+10);//删除疊代器位置處的單個字元, 并傳回下個元素的疊代器
ss.erase(ss.begin()+10, ss.end());//删除疊代器[first, last)區間的所有字元,傳回一個指向被删除的最後一個元素的下一個字元的疊代器

/*下圖描述*/
ss.begin();//函數傳回一個疊代器,指向字元串的第一個元素
ss.end();//傳回一個疊代器，指向字元串的末尾(最後一個字元的下一個位置)
ss.rbegin();//傳回一個逆向疊代器，指向字元串的最後一個字元
ss.rend();//傳回一個逆向疊代器，指向字元串的開頭（第一個字元的前一個位置）

//連接配接兩個字元串
cout<<ss+s1<<endl;
//倒轉字元串
#include<algorithm>
reverse(ss.begin(),ss.end());
//如果出現“ error: too many arguments to function call, expected 1, have 2”的報錯，則把“reverse”改為“::reverse”
C++回憶錄

四、int類型與string類型的互換

1.int—>string 

//int轉換為string類型
int a=12;
string aa=to_string(a);

//或者，此法隻能一個字元一個字元的轉換，不能轉換二位數以上的整數
int a=2;
char re=a+'0';

2.string—>int 

//string類型轉為int類型
string ss="123";
//stoi（字元串，起始位置，2~32進制），将n進制的字元串轉化為十進制。
int s1=stoi(ss,0,10);//從ss字元串的0位置開始，以十進制轉化

//或者
int s2=0;
for(int i=0;i<ss.size();i++){
	s2=s2*10+(ss[i]-'0');
}

五、關于math頭檔案中的常用函數

C++常用頭檔案——常用數學函數頭檔案

六、goto語句 

goto label;
..
.
label: statement;

七、ASCII碼轉換

在計算機存儲中，用ASCII碼表示字元，如字元char a,b，及整形int m:

1.擷取字元的ASCII碼：(int)a 或 m = a；

2.擷取ASCII碼對應的字元：(char)a 或 a = m；

3.字元之間相加減，實質是對應的ASCII碼相加減，結果為整形，如下列：

a - b 即a的ASCII碼減去b的ASCII碼，記為int k = a - b

結果：k

結果對應的字元：(char)k

轉載：https://blog.csdn.net/jianyingyao7658/article/details/83443914?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-2&spm=1001.2101.3001.4242

C++回憶錄

八、進制轉換

1.指定格式輸出 

//c++
cout << "35的8進制:" << std::oct << 35<< endl;  
cout << "35的10進制" << std::dec << 35 << endl;  
cout << "35的16進制:" << std::hex << 35 << endl;  
cout << "35的2進制: " << bitset<8>(35) << endl;      //<8>：表示保留8位輸出

//c
printf("%05o\n",35);    //按八進制格式輸出，保留5位高位補零
printf("%03d\n",35);    //按十進制格式輸出，保留3位高位補零
printf("%05x\n",35);    //按十六進制格式輸出，保留5位高位補零

2.使用字元串流string，stream 

#include<string>
#include<sstream>

（1）8,16->10（string—>int） 

string s="20";
int a;
stringstream ss;
ss<<hex<<s;    //以16進制讀入流中
ss>>a;        //10進制int型輸出

（2）10->8,16（int—>string） 

string s1,s2;
int a=30;
stringstream ss;
ss<<oct<<a;        //10進制轉成八進制讀入流中，再以字元串輸出
ss>>s1;            
cout<<s1<<endl;        //輸出：36
ss.clear();        //不清空可能會出錯。
ss<<hex<<a;         //10進制轉成十六進制讀入流中，，再以字元串輸出
ss>>s2;            
cout<<s2<<endl;        //輸出：1e

3.itoa函數（int—>char）(除了2進制—>*進制) 

#include <stdio.h>
#include <stdlib.h>
           
//函數原型
char *itoa(int value, char *str, int radix)

value 是被轉換的整數
str 轉換後存儲的字元數組
radix 轉換進制數，可以是 2， 8， 10， 16 等等

4.sprintf函數（int—>string）

當itoa不好使的時候，可以使用這個，功能更強大。

C++中sprintf()函數的使用詳解

int your_number;
char itoa_str[60+1];
sprintf(itoa_str, "%d", your_number);

5.stoi函數（string—>int）(*進制—>十進制） 

//函數原型
int stoi(const string &str, size_t* idx = 0, int base = 10)

str: 要轉換的string
idx: 為size_t*類型，是從str中解析出一個整數後的下一個字元的位置
base: 指出string中要轉換的數的進制，即str所代表的是個什麼進制的數,如是base預設為10， 若base = 0, 表示由編譯器自動判定str所代表的數的進制

//二進制——>十進制
int re=stoi("0001",0,2) //re=1

6.bitset（int/char/string—>bitset）(十進制—>二進制) 

bitset<4> bitset1;　　//無參構造，長度為４，預設每一位為０

bitset<8> bitset2(12);　　//長度為８，二進制儲存，前面用０補充

string s = "100101";
bitset<10> bitset3(s);　　//長度為10，前面用０補充

char s2[] = "10101";
bitset<13> bitset4(s2);　　//長度為13，前面用０補充

cout << bitset1 << endl;　　//0000
cout << bitset2 << endl;　　//00001100
cout << bitset3 << endl;　　//0000100101
cout << bitset4 << endl;　　//0000000010101

！！注意：取用bitset類型的index是反過來的！

例：bitset<8> re (“00011011”);

re[7] 為0

re[0] 為1

bitset<8> foo ("10011011");

cout << foo.count() << endl;　　//5　　（count函數用來求bitset中1的位數，foo中共有５個１
cout << foo.size() << endl;　　 //8　　（size函數用來求bitset的大小，一共有８位

cout << foo.test(0) << endl;　　//true　　（test函數用來查下标處的元素是０還是１，并傳回false或true，此處foo[0]為１，傳回true
cout << foo.test(2) << endl;　　//false　　（同理，foo[2]為０，傳回false

cout << foo.any() << endl;　　//true　　（any函數檢查bitset中是否有１
cout << foo.none() << endl;　　//false　　（none函數檢查bitset中是否沒有１
cout << foo.all() << endl;　　//false　　（all函數檢查bitset中是全部為１

九、關于algorithm頭檔案中常用函數

C++STL庫之algorithm庫

1.sort()函數

sort(first_pointer,first_pointer+n,cmp)

此函數有3個參數：

參數1：第一個參數是數組的首位址，一般寫上數組名就可以，因為數組名是一個指針常量。

參數2：第二個參數相對較好了解，即首位址加上數組的長度n（代表尾位址的下一位址）。

參數3：預設可以不填，如果不填sort會預設按數組升序排序。也就是1,2,3,4排序。也可以自定義一個排序函數，改排序方式為降序什麼的，也就是4,3,2,1這樣。

//對數組A的0~n-1元素進行升序排序
sort(A,A+n);

//對向量V排序
sort(v.begin(),v.end());

//自定義排序
bool compare(int a,int b) return a<b; //升序排列，如果改為return a>b，則為降序
sort(v.begin(),v.end(),compare);

十、類與結構體

1.類 

class Box
{
   public:
      double length;   // 長度
      double breadth;  // 寬度
      double height;   // 高度
      // 成員函數聲明
      Box(){}//構造函數
      double get(void);
      void set( double len, double bre, double hei );
};
// 成員函數定義
double Box::get(void)
{
    return length * breadth * height;
}
 
void Box::set( double len, double bre, double hei)
{
    length = len;
    breadth = bre;
    height = hei;
}
int main( )
{
   Box Box1;        // 聲明 Box1，類型為 Box
   Box Box2;        // 聲明 Box2，類型為 Box
   Box Box3;        // 聲明 Box3，類型為 Box
   double volume = 0.0;     // 用于存儲體積
 
   // box 1 詳述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 2 詳述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   // box 1 的體積
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的體積：" << volume <<endl;
 
   // box 2 的體積
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的體積：" << volume <<endl;
 
 
   // box 3 詳述
   Box3.set(16.0, 8.0, 12.0); 
   volume = Box3.get(); 
   cout << "Box3 的體積：" << volume <<endl;
   return 0;
}

2.結構體

例：職工有職工号，姓名，年齡.輸入n個職工的資訊，找出3個年齡最小的職工列印出來。關鍵字順序：年齡>工号>姓名，從小到大。

typedef struct Name{
    int age;
    int ID;
    string name;
}Name;

static bool comp(Name a,Name b)
{
    if(a.age<b.age)
        return true;
    else if(a.age==b.age)
    {
        if(a.ID<b.ID)
            return true;
        else if(a.ID==b.ID)
        {
            if(a.name<b.name)
                return true;
        }
    }
    return false;
}
 
int main()
{
    int N;
    while(cin>>N)
    {
        vector<Name> vec;
        Name temp;
        for(int i=0;i<N;i++)
        {
            cin>>temp.ID>>temp.name>>temp.age;
            vec.push_back(temp);
        }
         
        sort(vec.begin(),vec.end(),comp); //comp重寫排序方式
         
        for(int i=0;i<3;i++)
        {
            cout<<vec[i].ID<<" "<<vec[i].name<<" "<<vec[i].age<<endl;
        }
    }
    return 0;
}

十一、向量

向量（Vector）是一個封裝了動态大小數組的順序容器（Sequence Container）。跟任意其它類型容器一樣，它能夠存放各種類型的對象。可以簡單的認為，向量是一個能夠存放任意類型的動态數組。

#include<algorithm>
#include<vector>

向量的例子可以看上面的結構體。

C++ vector 容器淺析

以下是常用使用方法：

//定義int類型的向量
vector<int> vec;

//在數組最後增加資料
vec.push_back(12);

//在數組最後移除資料
vec.pop_back();

//删除第i項
vec.erase(vec.begin()+i);

//清除資料
vec.clear();

//翻轉數組，reverse屬于頭檔案<algorithm>
reverse(vec.begin(),vec.end());
//翻轉前m個
reverse(vec.begin(),vev.begin()+m);
//翻轉後m個
reverse(vec.end()-m,vec.end());

//預設設定排序，從小到大，sort屬于頭檔案<algorithm>
sort(vec.begin(),vec.end());

//自定義排序（本文章，第十章2.結構體，有相關應用）
//先寫個規則函數
bool comp(int a,int b){
	return a > b; //return a<b升序排序；return a>b，則為降序 
}
//排序容器
sort(vec.begin(),vec.end(),comp)
//降序也可以将預設排序後的vec倒過來
reverse(vec.begin(),vec.end()); 

//若想要像數組一樣取用，則如下定義
vector<int> vec = vector<int>(n, 0)；//初始化n個0  

//注意，sort函數屬于頭檔案<algorithm>，不僅可用于vector
int a[20]={2,4,1,23,5,76,0,43,24,65},i; 
for(i=0;i<20;i++) 
    cout<< a[i]<< endl; 
sort(a,a+20,compare);

十二、隊列

1.普通隊列 

//定義int類型隊列
queue<int> q;

//queue入隊
q.push(x); //将x 接到隊列的末端。

//queue出隊
q.pop(); //彈出隊列的第一個元素，注意，并不會傳回被彈出元素的值。

//通路queue隊首元素
q.front(); //即最早被壓入隊列的元素。

//通路queue隊尾元素
q.back(); //即最後被壓入隊列的元素。

//判斷queue隊列空
q.empty();//當隊列空時，傳回true。

//通路隊列中的元素個數
q.size();

2.單調隊列deque

deque 則是一種雙向開口的連續線性空間。所謂的雙向開口，意思是可以在頭尾兩端分别做元素的插入和删除操作。

C++回憶錄
//定義
deque<int> d;

d.size();//傳回容器中元素的個數

d.empty();//判斷容器是否為空

d.resize(num);//重新指定容器的長度為num,若容器變長，則以預設值填充新位置。如果容器變短，則末尾超出容器長度的元素被删除。

d.resize(num, elem); //重新指定容器的長度為num,若容器變長，則以elem值填充新位置,如果容器變短，則末尾超出容器長度的元素被删除。

//周遊容器
for(deque<int>::const_iterator it = d.begin(); it != d.end(); it++){
     cout<<*it<<" ";
}

d.push_back(elem);//在容器尾部添加一個資料

d.push_front(elem);//在容器頭部插入一個資料

d.pop_back();//删除容器最後一個資料

d.pop_front();//删除容器第一個資料

d.at(idx);//傳回索引idx所指的資料，如果idx越界，抛出out_of_range。

d.operator[];//傳回索引idx所指的資料，如果idx越界，不抛出異常，直接出錯。

d.front();//傳回第一個資料。

d.back();//傳回最後一個資料

d.insert(pos,elem);//在pos位置插入一個elem元素的拷貝，傳回新資料的位置。

d.insert(pos,n,elem);//在pos位置插入n個elem資料，無傳回值。

d.insert(pos,beg,end);//在pos位置插入[beg,end)區間的資料，無傳回值。

d.clear();//移除容器的所有資料

d.erase(beg,end);//删除[beg,end)區間的資料，傳回下一個資料的位置。

d.erase(pos);//删除pos位置的資料，傳回下一個資料的位置。

3.優先隊列priority_queue（堆） 

/*聲明形式:
type：資料類型；
container：實作優先隊列的底層容器；
function：元素之間的比較方式；*/
priority_queue< type, container, function >

定義大頂堆和小頂堆：

//需要注意的是，如果使用less<int>和greater<int>，需要頭檔案：
#include <functional>

//大頂堆聲明
//構造一個空的優先隊列（此優先隊列預設為大頂堆）
priority_queue<int> big_heap;   

//另一種建構大頂堆的方法
priority_queue<int,vector<int>,less<int> > big_heap2;

//小頂堆
//構造一個空的優先隊列,此優先隊列是一個小頂堆
priority_queue<int,vector<int>,greater<int> > small_heap;

成員函數：

//假設type類型為int，則：
priority_queue<int> heap;   

heap.empty();//傳回值為true，說明隊列為空；
heap.size();//傳回優先隊列中元素的數量；
heap.pop();//删除隊列頂部的元素，也即根節點
heap.top();//傳回隊列中的頂部元素，但不删除該元素；
heap.push(arg);//将元素arg插入到隊列之中；

十三、位運算符

C++回憶錄

十四、C++中的字典——Map

Map常見用法轉載

1.聲明 

map<int, string> ID_Name;

// 使用{}指派是從c++11開始的，是以編譯器版本過低時會報錯，如visual studio 2012
map<int, string> ID_Name = {
                { 2015, "Jim" },
                { 2016, "Tom" },
                { 2017, "Bob" } };

2.插入操作

2.1單個[]插入 

map<int, string> ID_Name;

// 如果已經存在鍵值2015，則會作指派修改操作，如果沒有則插入
ID_Name[2015] = "Tom";

2.2 insert函數 

// 插入單個鍵值對，并傳回插入位置和成功标志，插入位置已經存在值時，插入失敗
pair<iterator,bool> insert (const value_type& val);

//在指定位置插入，在不同位置插入效率是不一樣的，因為涉及到重排
iterator insert (const_iterator position, const value_type& val);

// 插入多個
void insert (InputIterator first, InputIterator last);

//c++11開始支援，使用清單插入多個   
void insert (initializer_list<value_type> il);

示例：

#include <iostream>
#include <map>

int main()
{
    std::map<char, int> mymap;

    // 插入單個值
    mymap.insert(std::pair<char, int>('a', 100));
    mymap.insert(std::pair<char, int>('z', 200));

    //傳回插入位置以及是否插入成功
    std::pair<std::map<char, int>::iterator, bool> ret;
    ret = mymap.insert(std::pair<char, int>('z', 500));
    if (ret.second == false) {
        std::cout << "element 'z' already existed";
        std::cout << " with a value of " << ret.first->second << '\n';
    }

    //指定位置插入
    std::map<char, int>::iterator it = mymap.begin();
    mymap.insert(it, std::pair<char, int>('b', 300));  //效率更高
    mymap.insert(it, std::pair<char, int>('c', 400));  //效率非最高

    //範圍多值插入
    std::map<char, int> anothermap;
    anothermap.insert(mymap.begin(), mymap.find('c'));

    // 清單形式插入
    anothermap.insert({ { 'd', 100 }, {'e', 200} });

    return 0;
}

3.取值

Map中元素取值主要有at和[ ]兩種操作，at會作下标檢查，而[]不會。

map<int, string> ID_Name;

//ID_Name中沒有關鍵字2016，使用[]取值會導緻插入
//是以，下面語句不會報錯，但列印結果為空
cout<<ID_Name[2016].c_str()<<endl;

//使用at會進行關鍵字檢查，是以下面語句會報錯
ID_Name.at(2016) = "Bob";

4.容量查詢 

// 查詢map是否為空
bool empty();

// 查詢map中鍵值對的數量
size_t size();

// 查詢map所能包含的最大鍵值對數量，和系統和應用庫有關。
// 此外，這并不意味着使用者一定可以存這麼多，很可能還沒達到就已經開辟記憶體失敗了
size_t max_size();

// 查詢關鍵字為key的元素的個數，在map裡結果非0即1
size_t count( const Key& key ) const; //

5.疊代器

共有八個擷取疊代器的函數：* begin, end, rbegin,rend* 以及對應的 * cbegin, cend, crbegin,crend*。

二者的差別在于，後者一定傳回 const_iterator，而前者則根據map的類型傳回iterator 或者 const_iterator。const情況下，不允許對值進行修改。如下面代碼所示：

map<int,int>::iterator it;
map<int,int> mmap;
const map<int,int> const_mmap;

it = mmap.begin(); //iterator
mmap.cbegin(); //const_iterator

const_mmap.begin(); //const_iterator
const_mmap.cbegin(); //const_iterator

傳回的疊代器可以進行加減操作，此外，如果map為空，則 begin = end。

C++回憶錄

6.删除交換

6.1删除 

// 删除疊代器指向位置的鍵值對，并傳回一個指向下一進制素的疊代器
iterator erase( iterator pos )

// 删除一定範圍内的元素，并傳回一個指向下一進制素的疊代器
iterator erase( const_iterator first, const_iterator last );

// 根據Key來進行删除， 傳回删除的元素數量，在map裡結果非0即1
size_t erase( const key_type& key );

// 清空map，清空後的size為0
void clear();

6.2交換 

// 就是兩個map的内容互換
void swap( map& other );

7.順序比較 

// 比較兩個關鍵字在map中位置的先後
key_compare key_comp() const;

map<char,int> mymap;
map<char,int>::key_compare mycomp = mymap.key_comp();

mymap['a']=100;
mymap['b']=200;
mycomp('a', 'b');  // a排在b前面，是以傳回結果為true

8.查找 

// 關鍵字查詢，找到則傳回指向該關鍵字的疊代器，否則傳回指向end的疊代器
// 根據map的類型，傳回的疊代器為 iterator 或者 const_iterator
iterator find (const key_type& k);
const_iterator find (const key_type& k) const;

std::map<char,int> mymap;
std::map<char,int>::iterator it;

mymap['a']=50;
mymap['b']=100;
mymap['c']=150;
mymap['d']=200;

it = mymap.find('b');
if (it != mymap.end())
    mymap.erase (it); // b被成功删除

9.操作符

operator: == != < <= > >=

注意 對于==運算符, 隻有鍵值對以及順序完全相等才算成立。

10.周遊map 

map<int, TaskInfo*> maps;
 
//以下循環是錯誤的.因為KEY不是順序号
//for（int i=0; i<maps.size();  i++） 
//TaskInfo* pInfo = maps[ i ];
 
//正确周遊:
map<int, TaskInfo*>::iter iter;
for (iter=maps.begin(); iter!=maps.end(); iter++){
     GH_LOG_INFO("%d, %s", iter->first, iter->second);
}

十五、數組操作

1.排序 

#include<algorithm>
int a[10]={1,2,3,4,5,6,7,8,9,10};
sort(a,a+alen); //alen是數組的長度
sort(a,a+2); //排序數組的前兩項

2.動态數組

動态配置設定數組空間，對于溢出問題比較友好。

2.1一維數組 

//一維
int *p=new int[20];

//釋放空間
delete []p;  //釋放這個一維的動态數組，而不是釋放指針p。用完以後要記得釋放掉

2.2二維數組 

#include<iostream>
using namespace std;
int main()
{
   int m,n;   //輸入數組大小
   int *column;
   int **p;   //聲明一個二級指針
   cin>>m;
   column=new int[m];  //column用來記錄每行元素的個數，因為每行元素的個數可能不同，如果都相同的話就不需要了
   p=new int*[m]; //建立了一個有m行的的二維動态數組；可以看成數組p[m]中每個元素都是指針，用來指向一個數組
   for(int i=0;i<m;i++)
   {
       cin>>n; 
       column[i]=n;
       p[i]=new int[n];  //确定每行元素的個數，p[i](一級指針)為每行元素的首位址

   }
   for(int i=0;i<m;i++) //輸入每行元素的值
   {
       for(int j=0;j<column[i];j++)
         cin>>p[i][j];
   }
   cout<<"---------輸出每行元素-----------\n";
   for(int i=0;i<m;i++)  //輸出每行元素
   {
       for(int j=0;j<column[i];j++)
         cout<<p[i][j]<<" ";
       cout<<endl;
   }

   for(int i=0;i<m;i++)  //用完釋放掉每行(釋放二級指針)
       delete []p[i];
   delete []p;  //釋放掉每行後，再釋放這個二維數組(釋放一級指針)
   cout<<"指針p的位址："<<p;    //輸出指針p的位址
   return 0;
}

十六、棧 

//定義棧
stack<int> s1;

s1.empty(); //堆棧為空則傳回真

s1.pop(); //移除棧頂元素，不傳回元素

s1.push(); //在棧頂增加元素

s1.size(); //傳回棧中元素數目

s1.top(); //傳回棧頂元素

十七、setw()函數

C++ setw() 函數用于設定字段的寬度，文法格式如下：

setw(n)

n 表示寬度，用數字表示。

setw() 函數隻對緊接着的輸出産生作用。

當後面緊跟着的輸出字段長度小于 n 的時候，在該字段前面用空格補齊，當輸出字段長度大于 n 時，全部整體輸出。

C++回憶錄
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    // 開頭設定寬度為 4，後面的 runoob 字元長度大于 4，是以不起作用
    cout << setw(4) << "runoob" << endl;
    // 中間位置設定寬度為 4，後面的 runoob 字元長度大于 4，是以不起作用
    cout << "runoob" << setw(4) << "runoob" << endl;
    // 開頭設定間距為 14，後面 runoob 字元數為6，前面補充 8 個空格 
    cout << setw(14) << "runoob" << endl;
    // 中間位置設定間距為 14 ，後面 runoob 字元數為6，前面補充 8 個空格 
    cout << "runoob" << setw(14) << "runoob" << endl;
    return 0;
}

/*
結果如下：
runoob
runoobrunoob
        runoob
runoob        runoob
*/
setw()函數内容轉載自：https://www.runoob.com/w3cnote/cpp-func-setw.html

十八、set

set的特性是，所有元素都會根據元素的鍵值自動排序，set的元素不像map那樣可以同時擁有實值(value)和鍵值(key),set元素的鍵值就是實值，實值就是鍵值。set不允許兩個元素有相同的鍵值。

//定義
int arr[5] = {0,1,2,3,4};
set<int> iset(arr,arr+5);

set<int> ss;

ss.insert(5);//--在集合中插入元素
ss.begin();//--傳回指向第一個元素的疊代器
ss.clear();//--清除所有元素
ss.count(5);//--傳回某個值元素的個數,隻會傳回0和1
ss.empty();//--如果集合為空，傳回true
ss.end();//--傳回指向最後一個元素的疊代器
ss.equal_range(5);//--傳回一對定位器，分别表示第一個大于或等于給定關鍵值的元素和第一個大于給定關鍵值的元素，這個傳回值是一個pair類型，如果這一對定位器中哪個傳回失敗，就會等于end()的值。

/*
erase(iterator)  ,删除定位器iterator指向的值
erase(first,second),删除定位器first和second之間的值
erase(key_value),删除鍵值key_value的值
*/
ss.erase(5);//--删除集合中的元素

ss.find(5);//--傳回一個指向被查找到元素的疊代器
ss.get_allocator();//--傳回集合的配置設定器
ss.lower_bound(5);//--傳回指向大于（或等于）某值的第一個元素的疊代器
ss.upper_bound(5);//--傳回大于某個值元素的疊代器
ss.max_size();//--傳回集合能容納的元素的最大限值
ss.rbegin();//--傳回指向集合中最後一個元素的反向疊代器
ss.rend();//--傳回指向集合中第一個元素的反向疊代器
ss.size();//--集合中元素的數目

//交換集合s1和s2
s1.swap(s2);  //交換兩集合
c++ 字元串 leetcode
上一篇: 寫在退役之後&amp;OI回憶錄
下一篇: C++ 回憶錄1

繼續閱讀