2016年下半年開始接觸音視頻相關(guān)的項目,在這之前對C++沒有系統(tǒng)的學(xué)習(xí)過,就在中國大學(xué)MOOC上學(xué)習(xí)了西安交通大學(xué)的計算機程序設(shè)計（C++）,課程學(xué)完之后把做的筆記總結(jié)出來發(fā)布到了自己的博客便于以后復(fù)習(xí),最近發(fā)現(xiàn)訪問不太穩(wěn)定,同時也動了想要把遇到的問題以及解決方式記錄下來的心思,起因是因為發(fā)現(xiàn)好多遇到過的問題當(dāng)時花好多時間解決了,過了很長一段時間再遇到就忘記當(dāng)時是怎么解決的了導(dǎo)致時間浪費,另外做筆記也能夠重新思考一遍加深一次印象,才把之前博客上的內(nèi)容遷移到簡書上。

優(yōu)先級:后置++ > 前置++ > 乘除

int a=3; //全局變量
int main()
{
int a =8;
cout<<a<<endl; //同名變量,局部變量優(yōu)先級高于全局變量
}
//如果想使用全局變量而不是局部變量,應(yīng)在變量前加上作用域運算符"::"即可.

變量的存儲類型,C++程序運行時使用的內(nèi)存區(qū)域

所有共用成員函數(shù)代碼區(qū)對象中的函數(shù)成員共用一個存儲空間,在代碼區(qū)存放.

存儲類型 auto,register,static,extern

一個變量完整形式

<存儲類型> <數(shù)據(jù)類型> <變量名>;

• auto:在定義塊的開始分配空間,執(zhí)行結(jié)束時釋放空間,函數(shù)的自動變量(auto)是在函數(shù)執(zhí)行中才分配.
• register:盡可能存放在CPU的寄存器中,提高程序的效率,僅局部變量和形式參數(shù)才可作為寄存器變量.
• static變量是在編譯時才分配的內(nèi)存.如果在全局變量前加上static修飾符,則成為靜態(tài)全局變量,只能在本文件中使用
• extern:如果在一個源文件a.cpp中定義的全局變量想在b.cpp文件中使用,則應(yīng)該在b.cpp中使用,則應(yīng)該在b.cpp中加上extern進行聲明,表示該全局變量不在b.cpp中定義的

a.cpp
int Dimension =100;

b.cpp
使用的話,應(yīng)該聲明如下
extern int Dimension;

位運算符

&按位”與”

a=01101001B
b=01011110B //&,全1為1全0為0
c=01001000B

|按位”或”

a=01101001B
b=01011110B  //|,有1為1其他為0
c=01111111B

^按位異或

a=01101001B
b=01011110B //^,不同為1,相同為0
c=00110111B

~按位取反

//如:整數(shù)是4個字節(jié)占32位,補全之后對應(yīng)位取反

字符的處理

字符串占的字節(jié)數(shù)=字符串的長度+1.如”程序設(shè)計”(4個漢子占8個字節(jié)),末尾加了一個結(jié)束符’\0’,所有+1個字符.

有些ASCII符號是不可顯示的,如轉(zhuǎn)義字符:

\n 換行符 ,\r 回車, \b 退格符,\t 制表符 ,\’ 單引號, \’’雙引號, \0 字符串結(jié)束符, \f 分頁符.

char *strcat(char *destin,char *source) //鏈接兩個字符
char *strcpy(char *destin,char *source)//將字符串source拷貝到destin中
char *strlwr(char *string) //string轉(zhuǎn)換成小寫
char *strupr(char *string)//string轉(zhuǎn)換成大寫
String text ="heavy rains are pushing water";
k = text.find("heavy");
text.erase(k,sizeof("heavy")-1);
text.insert(k,"strong");

指針(*and&)

1.我們將存放地址的變量稱為指針變量,這里的地址就是指針,指針也是數(shù)據(jù)類型.

2.*是指針類型變量的標(biāo)識符

3.定義一個指針變量系統(tǒng)為該指針變量分配一定大小的內(nèi)存(C++中,每個指針變量占有8個字節(jié)長度)

int a,*pta;//先定義變量

pta = &a;不可寫成 *pta=&a;

/*
*pta并不表示指針變量pta.而表示pta指向的變量a.指針變量和指針變量所指向的變量完全是不同的概念.

&取地址運算符,&變量名 //獲取變量的內(nèi)存單元地址

*指針運算符(間接訪問運算符)

指針變量pta存放著變量a的指針,則*pta表示pta所指向的變量,即變量a.
*/

int a =5; *p =&a;

cout<<&a<<endl;//a的地址

cout<<a<<endl;//變量a的值

cout<<*p<<endl;//p指向的變量

//函數(shù)在編譯時被分配了一個入口地址,這個入口地址就稱為函數(shù)的指針.

char name1[50];

//name1是字符數(shù)組name1的首地址,也就是&name1[0];

//指針+/-整數(shù)---->指針

假設(shè):int a[10] ={10,20,30},*p=a,i;

p+i:表示p所指元素之后的第i個元素的指針,p指向的是int類型,int類型變量為4個字節(jié)長度,

所以p+1,相當(dāng)于指針P+4,p+i相當(dāng)于p+4*i

1000 |10

1004 |20

1008 |30

100C |...




//同類型的指針做減法運算

//指針2-指針1 --->整數(shù),常用于計算兩個指針間包含元素的個數(shù).

(指針2-指針1)/元素字節(jié)長度 =元素個數(shù)

int a[];*p=a,i;

a+i表示對象的地址

*(a+i)表示指向的對象

char str[81],*pstr;

str ='abcd';錯誤,數(shù)組名是常量指針!不能被賦值

結(jié)構(gòu)體指針

結(jié)構(gòu)體變量的指針 &結(jié)構(gòu)體變量名

指向結(jié)構(gòu)體變量的指針 結(jié)構(gòu)體類型 *指針變量名

struct telelist{
char name[8];
char sex;
char num[15];
char num2[15];
}List[3];
//表示list包含telelist這種格式的3個元素

結(jié)構(gòu)體指針訪問結(jié)構(gòu)體中變量中的成員

1.(*指針變量).成員名
2.指針變量->成員名  //->稱為結(jié)構(gòu)體指向運算符
例如:
Date d = {2015,4,8},*p = &d; //定義日期結(jié)構(gòu)體變量和指針變量
(*p).year  p->year

delete運算符:釋放動態(tài)申請到的存儲空間

1.動態(tài)釋放單個變量
delete 指針變量 ; //釋放單個動態(tài)變量

2.動態(tài)釋放數(shù)組
delete []指針變量 ;//釋放動態(tài)數(shù)組

new運算符->動態(tài)申請所需的內(nèi)存空間

1.動態(tài)申請單個變量
指針變量 = new 類型;
double *p;
p= new double(100.0);

2.動態(tài)申請數(shù)組
指針變量 = new 類型[元素個數(shù)];
char *str;
str =new char[80];
cin>>n; p = new int [n];
if(p=NULL){
cout<<"空間申請失敗!";
}

抽象&封裝

結(jié)構(gòu)體和類的區(qū)別?

1.結(jié)構(gòu)體只有數(shù)據(jù)成員沒有函數(shù)成員.
2.類=數(shù)據(jù)成員+函數(shù)成員
3.結(jié)構(gòu)體又稱為特殊的類,現(xiàn)在的結(jié)構(gòu)體中也可以包含函數(shù)成員

1.內(nèi)聯(lián)函數(shù)

//在類體內(nèi)直接定義的函數(shù)成員,該函數(shù)成員又稱為內(nèi)聯(lián)函數(shù)

Class clock{
void show_Time(){cout<<hour:<<:<<minute<<endl;} //內(nèi)聯(lián)函數(shù)
}

inline int square(int x)
{
return x*x;
}
int sum =0;
sum+=square(i);

//編譯時遇到內(nèi)聯(lián)函數(shù)調(diào)用square(i),實參換形參,sum+=square(i);將被替換為sum+=i*i;

2.在類體外定義函數(shù)成員

<類型><類名> :: <函數(shù)名>(<參數(shù)列表>)
{
<函數(shù)體>
}

//::表示作用域符號

面向過程

以功能為中心,通過分解問題的功能,采用函數(shù)描述數(shù)據(jù)與函數(shù)分離,數(shù)據(jù)(類型或結(jié)構(gòu))發(fā)生變化,函數(shù)也要發(fā)生相應(yīng)變化.

如 void sort(int a[],int n);//只能排整數(shù)的數(shù)組

面向?qū)ο?/h3>

以數(shù)據(jù)為中心,采用對象來描述內(nèi)部屬性和操作方法,將數(shù)據(jù)和函數(shù)當(dāng)做一個統(tǒng)一體,采用軟件對象來描述客觀對象.

構(gòu)造函數(shù)

構(gòu)造函數(shù),用于創(chuàng)建一個對象,提供了初始化該對象的手段.成員函數(shù)完成初始化數(shù)據(jù)成員.

constructor 在對象創(chuàng)建時執(zhí)行,提供了初始化對象的一種簡便手段.

Destructor 在對象被撤銷時(前)執(zhí)行,用于完成對象被銷毀前的一些清理工作.

往往用于釋放constructor中動態(tài)申請的內(nèi)存空間.

Destructor 語法格式

<類名>::~<類名>(){<函數(shù)體>}

功能:撤銷對象前進行一些善后處理工作,由系統(tǒng)調(diào)用.類名前加~.

Class robot{
robot();//構(gòu)造函數(shù)
{
strcpy(name,"xx");
strcpy(type,"xx");
}

void set(char n[],char t[],int m); //設(shè)置修改數(shù)據(jù)
~robot(){delete []ps;} //釋放構(gòu)造函數(shù)和set函數(shù)中動態(tài)申請的空間
}

繼承(inheritance)

從以前定義的類(基類)產(chǎn)生新類的過程為派生,新產(chǎn)生的類為派生類

派生類的定義

Class 派生類名 :繼承方式(即是訪問權(quán)限) 基類名1
Class singStar:public Person
//對基類的擴充/對基類成員的改造,系統(tǒng)默認就是私有繼承

訪問權(quán)限

• public(基類共有成員,基類保護成員)
• protected(基類的public和protected成員相當(dāng)于派生類的保護成員,派生類可以通過子類和自身的成員函數(shù)訪問他們)
• private(基類的public和protected成員相當(dāng)于派生類的私有成員,派生類只能通過函數(shù)成員訪問)

基類的constructor和destructor不能被繼承

派生類的構(gòu)造函數(shù)一般形式為

派生類名::派生類名(參數(shù)列表):基類名1(參數(shù)列表1)…內(nèi)嵌對象名(對象參數(shù)表)

Class Employee:public Person
{
Person lerader;//內(nèi)嵌對象
char Dept[20];
}

Employee(char *name,int age,char *dept,char name,int age):Person(name,age),Leader(name1,age1)

Cylinder::cylinder(int x,int y,double r,double h):Circle(x,y,r);

多態(tài)

相同語法結(jié)構(gòu),代表不同的功能和操作,一種接口多種方法

• 編譯時多態(tài)性:編譯器對源程序編譯時可以確定調(diào)用哪一個函數(shù),通過重載實現(xiàn)(參數(shù)類型不同)
• 運行時多態(tài)性:在運行過程中確定調(diào)用哪一個函數(shù),通過虛函數(shù)來實現(xiàn)

dog,cat:Pet
pet pet1;
*p = &pet1;
cin>>x;
if(x==1) p = &cat1;
if(x==2) p = &dog1;
p->speak();//只有運行時才知道,究竟運行哪個函數(shù)
Class Pet{
public;
virtual void speak(){
cout<<"222"<<endl;
}
}
//virtual使得speak為虛函數(shù),實現(xiàn)基類指針訪問派生類的成員函數(shù).

虛函數(shù)

基類加入virtual的函數(shù)是虛函數(shù),子類可以重寫虛函數(shù)實現(xiàn)對父函數(shù)的覆蓋.

當(dāng)想用派生類的成員函數(shù)取代基類的同名函數(shù)時,C++要求你必須預(yù)先通知編譯器.通知的方法就是在可能被取代的基類成員函數(shù)前面加上virtual關(guān)鍵字.

在計算機領(lǐng)域virtual的意思是用戶看到的東西事實上并不存在,它只是用某種方法支撐的幻覺罷了.這里他的意思是不讓用戶看到事實上存在的東西(基類的成員函數(shù)).

virtual可以替換成另外一個關(guān)鍵字會更加確切choose_the_appropriate_method_at_runtime_for_whatever_object_this_is(在運行時根據(jù)對象的類型選擇合適的成員函數(shù)),這里也可以替換成一個更簡單的詞placeholder.

不管怎么如果需要調(diào)用基類的成員函數(shù)可以使用下面的方法:

p->Fruit::peel();

為什么成員函數(shù)不缺省使用virtual?

不能缺省virtual的原因和C語言不能缺省使用register關(guān)鍵字有異曲同工之妙,它是一種笨拙的優(yōu)化措施.既然不是每個成員函數(shù)都需要這種運行時的間接形式,那為什么要讓每一個成員函數(shù)都添加一個額外的負擔(dān)呢?應(yīng)該顯示的告訴編譯器哪些成員函數(shù)需要多態(tài).

定義:

函數(shù)定義的頭部加上virtual,該函數(shù)就是虛函數(shù).在基類中聲明為virtual并在派生類中重新定義的同名函數(shù),成為虛函數(shù).

格式:

virtual 函數(shù)返回類型 函數(shù)名(參數(shù)列表){
函數(shù)體
}

用處:

實現(xiàn)運行時的多態(tài)性,通過基類指針訪問派生類中的同名覆蓋函數(shù)

使用限制:

應(yīng)該通過指針或引用調(diào)用虛函數(shù),而不能以對象名調(diào)用虛函數(shù).

pet obj;
Dog dog1;
obj =dog1;
obj.speak();//執(zhí)行基類的speak()函數(shù)
Pet *pet1 =&dog1;
pet1->speak(); //執(zhí)行是Dog類的speak()函數(shù).
//在派生類重定義基類的虛函數(shù)仍為虛函數(shù),同時可省略virtual關(guān)鍵字.
//不能定義虛constructor函數(shù),可以定義虛destructor函數(shù).

抽象類

• 將那些并不用來聲明對象(實例化)的類稱為抽象類,只供繼承.
• 具體實現(xiàn)只能在派生類中完成,抽象類又可以定義成:至少包含一個純虛函數(shù)的類,虛函數(shù)是多態(tài)的一種形式,作用是實現(xiàn)函數(shù)的覆蓋.

純虛函數(shù)定義:

virtual  返回類型  函數(shù)名(參數(shù)列表) = 0

虛析構(gòu)函數(shù):通過基類指針可以釋放派生類對象的空間.

Class Base{
void show();
virtual void Base::show{cout<<x<<endl;} //調(diào)用時說明virtual虛函數(shù)是不正確的
}

Class Base
{
virtual void show(); //聲明
}
void Base::show(){cout<<x<<endl;}//類外定義

函數(shù)模板

根據(jù)函數(shù)實參中的類型來確認是否匹配函數(shù)模板中對應(yīng)的形參,然后生成一個重載函數(shù).

template <class T> //class指某種類型(char,int,struct)

//類模板定義
template <class <類型參數(shù)>>
迭代器  確定元素位置的數(shù)據(jù)類型,可用來遍歷容器中的元素,可以讀取,修改它指向的元素.
vector 對動態(tài)數(shù)組的封裝,能夠插入元素且能夠自動調(diào)整容器大小.
創(chuàng)建10個元素的向量
vector <String> s2(10);
v1.Insert(v1.end()-1,3);//倒數(shù)第2的位置上插入元素向迭代器

輸入/輸出流

ifstream //對象只進行讀操作
ofstream //對象只進行寫操作
fstream //可讀可寫

istream & getline(char *pch,int ncount,char delim='\n')
pch:讀取多個字符放在pch中,ncount:讀取字符的上限,讀取字符到delim結(jié)束,終止字符被舍棄.
cin.getline();//將指針移到終止字符之后
cin.get(); //將指針移到終止字符處

打開文件

void open(const char *fileName,openMode mode)
ifstream in("file.txt");
if(!in) //不可以打開文件

打開文件用于輸入

ifstream file1; file1.open("grade.txt");

打開文件用于輸出

ofstream file2; file2.open("c:\msg.txt");

以二進制的形式打開文件 c:\abc.bmp

fstream file3; file3.open("c:\abc.bmp",ios::binary|ios::in);

二進制文件讀寫函數(shù)

二進制文件輸入數(shù)據(jù)

istream &read(char *buffer,int len);

二進制文件輸出數(shù)據(jù)

ostream &write(const char *buffer,int len);

STL(Standard Template Library)

Map

你有必要包含,maps是std命名空間的一部分,maps需要2到3種類型對于模板

you will need to include and maps are part of the std namespace. Maps require two, and possibly three, types for the template:

std::map <key_type, data_type, [comparison_function]>
std::map <string, char> grade_list;
grade_list["John"] = 'B';
// John's grade improves
grade_list["John"] = 'A';

需要調(diào)用一個erase函數(shù)進行刪除map中的一個成員

requires calling the function erase, which is a member of the map class

erase(key_type key_value);
grade_list.erase("John");

how many values the map contains by using the size function

int size();

we could call the size function on the grade list:

std::cout<<"The class is size "<<grade_list.size()<<std::endl;

If we’re only interested in whether the map is empty, we can just use the map member function empty:

bool empty();

If you want guarantee that the map is empty, you can use the clear function.

grade_list.clear();

一個key是否在map中有對應(yīng)的value,你需要調(diào)用find函數(shù)如果有這個key對應(yīng)的value時將會返回一個iterator,如果沒有發(fā)現(xiàn)key對應(yīng)的value迭代器將會指向這個 map_name.end()

whether a key has an associated value in a map,you need to use the find function, which will return an iterator pointing to the value of the element of the map associated with the particular key, or if the key isn’t found, a pointer to the iterator map_name.end()

std::map <string, char> grade_list;
grade_list["John"] = 'A';
if(grade_list.find("Tim") == grade_list.end())
{
    std::cout<<"Tim is not in the map!"<<endl;
}
std::map<parameters>::iterator iterator_name;

包含兩個成員,第一個對應(yīng)的是key,第二個對應(yīng)的是value,迭代器被當(dāng)做是一個指針去訪問成員變量,你需要用->去取消引用這個迭代器

essentially has two members, first and second. First corresponds to the key, second to the value. Note that because an iterator is treated like a pointer, to access the member variables, you need to use the arrow operator, ->, to “dereference” the iterator.

the following sample shows the use of an iterator (pointing to the beginning of a map) to access the key and value.

std::map <string, char> grade_list;
grade_list["John"] = 'A';
// Should be John
std::cout<<grade_list.begin()->first<<endl;
// Should be A
std::cout<<grade_list.begin()->second<<endl;

List

向量相對比較花費時間插入向量中,但是能夠很快的進行隨機訪問,鏈表比較容易插入但是訪問比較困難

The vector has relatively costly insertions into the middle of the vector, but fast random access, whereas the list allows cheap insertions, but slow access (because the list has to be traversed to reach any item),declares a list storing integers:

std::list<int> integer_list;

新的元素將會各自插在鏈表的開頭和結(jié)尾用push_back and push_front 兩個函數(shù)

Like the vector class, the list class includes the push_back and push_front functions, which add new elements to the front or back of the list respectively.

std::list<int> integer_list;
integer_list.push_front(1);
integer_list.push_front(2);

插入需要一個迭代器指向這個元素應(yīng)該被插入的位置,新的元素將會被插入當(dāng)前指向的

元素之前

insert requires an iterator pointing to the position into which the element should be inserted (the new element will be inserted right before the element currently being pointed to will). iterator insert(iterator position, const T& element_to_insert);

鏈表返回一個迭代器在鏈表的第一個元素,返回一個迭代器在元素在鏈表的最后,你能聲明一個迭代器作為其他對象的容器

Fortunately, the list container supports both the begin – returning an iterator to the beginning of the list – and end – returning an iterator past the last element of the list – iterator functions, and you can declare iterators as with any other container, in the following manner:

list<type>::iterator iterator_name;

增加一個元素與在鏈表的結(jié)尾也可以這樣實現(xiàn):

using insert and the function end, the functionality of push_back, which adds an element to the end of the list, could also be implemented as

std::list<int> integer_list;
integer_list.insert(integer_list.end(), item);

鏈表包含兩個函數(shù)size,empty,size的時間復(fù)雜度是O(N),如果你想要測試一個鏈表是否為空用empty函數(shù)代替size函數(shù),如果你想保證這個鏈表為空,就要用clear函數(shù)

排序算法僅僅提供能隨機訪問迭代器,不提供排序在鏈表容器中,這時候就有必要用成員函數(shù)進行排序了

instance_name.sort();

Lists can be reversed using

instance_name.reverse();

其中一個特點,用逆序成員函數(shù)取代算法逆序是它不影響如果正在被其他迭代器指向的值.

Another potentially useful list function is the member function called unique; unique converts a string of equal elements into a single element by removing all but the first element in the sequence. For instance, if you had a list consisting of

另外一個可能的用法鏈表的函數(shù)是一個成員函數(shù)被調(diào)用unique,刪除鏈表中相同的元素最后只保留一個,如果你有一個鏈表包含如下

1 1 8 9 7 8 2 3 3

the calling unique would result in the following output:可以發(fā)現(xiàn)仍然還有兩個8,僅僅挨著的兩個元素其中一個被刪除了

1 8 9 7 8 2 3

你如果想要把相同的元素只保留一個,就需要先排序再調(diào)用unique函數(shù).

If you want each element to show up once, and only once, you need to sort the list first! Try the following code to see how this works and see many of the previous functions in action!,

std::list<int> int_list;

int_list.push_back(1);

int_list.push_back(1);

int_list.push_back(8);

int_list.push_back(9);

int_list.push_back(7);

int_list.push_back(8);

int_list.push_back(2);

int_list.push_back(3);

int_list.push_back(3);

int_list.sort();

int_list.unique();

for(std::list<int>::iterator list_iter = int_list.begin(); 

    list_iter != int_list.end(); list_iter++)

{

    std::cout<<*list_iter<<endl;

}

The Good

• Lists provide fast insertions (in amortized constant time) at the expensive of lookups (鏈表能夠快速的插入以固定的時間),在查找時比較耗時
• Lists support bidirectional iterators, but not random access iterators,鏈表支持雙向的迭代器,但不支持隨機讀取的迭代器
• Iterators on lists tend to handle the removal and insertion of surrounding elements well,鏈表上的迭代器更傾向于手動插入,刪除周圍的元素

The Gotchas

• Lists are slow to search, and using the size function will take O(n) time,鏈表遍歷起來非常慢,用size函數(shù)的時間復(fù)雜度為O(N)
• Searching for an element in a list will require O(n) time because it lacks support for random access,遍歷一個元素的時間復(fù)雜度是O(N),它缺少隨機訪問的支持

容器&迭代器

• 容器（Container），是一種數(shù)據(jù)結(jié)構(gòu)煤惩，如list笛质，vector，和deques 讶舰，以模板類的方法提供

• 迭代器（Iterator）鞍盗，提供了訪問容器中對象的方法。Iterator（迭代器）模式又稱Cursor（游標(biāo)）模式跳昼，用于提供一種方法順序訪問一個聚合對象中各個元素, 而又不需暴露該對象的內(nèi)部表示般甲。

迭代器的作用：能夠讓迭代器與算法不干擾的相互發(fā)展，最后又能無間隙的粘合起來鹅颊，重載了*敷存，＋＋，＝＝堪伍，Ｃ场＝，＝運算符杠娱。用以操作復(fù)雜的數(shù)據(jù)結(jié)構(gòu)挽牢，容器提供迭代器，算法使用迭代器摊求；

vector<T>::iterator it;
list<T>::iterator it;deque<T>::iterator it禽拔；

從容器中讀取元素。

• 輸入迭代器只能一次讀入一個元素向前移動，輸入迭代器只支持一遍算法睹栖，同一個輸入迭代器不能兩遍遍歷一個序列output:向容器中寫入元素硫惕。
• 輸出迭代器只能一次一個元素向前移動。輸出迭代器只支持一遍算法野来，統(tǒng)一輸出迭代器不能兩次遍歷一個序列
• forward:組合輸入迭代器和輸出迭代器的功能恼除，并保留在容器中的位置bidirectional:組合正向迭代器和逆向迭代器的功能，支持多遍算法random access:組合雙向迭代器的功能與直接訪問容器中任何元素的功能曼氛，即可向前向后跳過任意個元素

盡管你的編譯器可能沒有實現(xiàn)名字空間豁辉，你仍然可以使用他們。為了使用STL舀患，可以將下面的指示符插入到你的源代碼文件中徽级，典型地是在所有的#include指示符的后面：using namespace std;

參考資料:

http://www.cprogramming.com/tutorial/stl/stlmap.html

http://www.cprogramming.com/tutorial/stl/stllist.html

計算機程序設(shè)計（C++(西安交通大學(xué))