ISO C++基本類型和變量

時間：2018-06-05 08:40:07

關鍵字： iso 變量類型

手機看文章

掃描二維碼
隨時隨地手機看文章

[導讀]基本類型和變量. 像其他高級語言一樣,ISO C++除了像C一樣,有自己的基本類型:字符型,整形,浮點型等,還提供了可用于自定義類型機制.所謂的C++ STL,正是這個機制定義了大量的類型和操作. 比如可變長的string,vector等.一

基本類型和變量.

像其他高級語言一樣,ISO C++除了像C一樣,有自己的基本類型:字符型,整形,浮點型等,還提供了可用于自定義類型機制.所謂的C++ STL,正是這個機制定義了大量的類型和操作.

比如可變長的string,vector等.一般和C一樣,也是為了兼容C,內置類型一般小寫.

對于所謂內置類型不同,一般指位數不同而已,比如int 16(當然這個有爭議,很多語言都是32位,所以C++又定義了一個long 32)和float(32位),當然也有不同的類型位數一樣,比如剛才int 和 short都是16.

其實所有的這一切都是編譯器想怎么解釋就怎么解釋(也有標準的約束).

像C語言一樣,C++的字符用單引號,字符串用雙引號,這點和pascal不同,pascal都用單引號,編譯器自行解釋.另外,和pascal不同的是,C++/C定義常量,也用特殊標識,比如字符串前加"L"代表unicode串,整形后加L表示long型,也就是32位的.

與C一樣,都用""作轉義字符.整形和字符型在一定范圍兼容.

作用域:C++比C多了名字空間作用域,類作用域(其實C也有struct作用域).

頭文件,C直接用.h結尾的文件,而現(xiàn)在的C++頭文件一般都不帶.h,比如 #include <string> #include <string.h>,前者定義有string類型,而后者則是一些char *處理函數.

C/C++都有特殊類型,引用(符號&), 引用其實就是一個變量的別名,僅此而已.像const變量一樣,引用必須初始化. 如:int i; int &reint = i;正因為引用是別名,所以不能直接對其賦值,&reint = i;(error).

枚舉類型:其實就是定義一些常量的集合.關鍵字enum mode {input,output,append};枚舉類型都有默認的值,從第一個為0開始,后面依次加1,input = 0,output = 1,append =2.當然也可以給定其初始化值.enum mode {input = 1,output,append};

像C一樣,關鍵字typedef可以定義復雜的類型.比如typedef void (Message_Process::*FN_Msg)(Message*); FN_Msg為函數指針類型,可以用其定義其他的變量,比如FN_Msg p = NULL;

與C不同的是,C++有class關鍵字.標準庫通過他,定義大量的數據類型,比如string,istream,ostream等等.雖然class和 struct差不多,但class機制更復雜,主要就是他定義了一組權限規(guī)則,private,protected,public.(記得類后面有;號啊)struct內部的成員都是public屬性.

C++標準庫(STL)

首先名字空間using namespace std; 當然也可以直接using std::cin;

現(xiàn)在我們來玩玩string這個東東.這個東東在pascal里也有,內存分配是引用計數 +Length + ansichar*,在string里,在C++里只知道是一個常用對象,具體怎么分配的,網上好多垃圾也沒有說清楚.只說什么copyonwrite亂七八糟之云乎.既然是類,那么就要遵循C++實例規(guī)則.C++沒有pascal那么嚴格,pascal里只有明確的create才能創(chuàng)造對象,C++到處都暗藏殺機.很多隱式定義.

string定義(四種):

string s1;

string s2(s1);//定義并初始化

string s3("value");//常量初始化

string s4(n,'c');//相同字符常量初始化

運算符重載(+,=(賦值),==,!=,>,<等等)

成員函數size和empty判斷長度.

string::size_type類型

template<class E, //定義模板類,泛型化

class T = char_traits<E>, //T,A也一個泛型實例的類

class A = allocator<T> > //泛型類

class basic_string {

public:

typedef T traits_type; //定義泛型類型

typedef A allocator_type;

typedef T::char_type char_type; //這里A和T只是一個類域而已

typedef A::size_type size_type;

typedef A::difference_type difference_type;

typedef A::pointer pointer;

typedef A::const_pointer const_pointer;

typedef A::reference reference;

typedef A::const_reference const_reference;

typedef A::value_type value_type;

typedef T0 iterator;

typedef T1 const_iterator;

typedef reverse_iterator<iterator, value_type,

reference, pointer, difference_type>

reverse_iterator;

typedef reverse_iterator<const_iterator, value_type,

const_reference, const_pointer, difference_type>

const_reverse_iterator;

static const size_type npos = -1;

//隱式構造函數 ,以下都是其構造函數

explicit basic_string(const A& al = A()); //string str;分配一空字符串

basic_string(const basic_string& rhs); //string str(s1);

basic_string(const basic_string& rhs, size_type pos, size_type n, //string s4(str,1,5);用另一個字符串的一節(jié)去構造

const A& al = A());

basic_string(const E *s, size_type n, const A& al = A()); //

basic_string(const E *s, const A& al = A());

basic_string(size_type n, E c, const A& al = A());

basic_string(const_iterator first, const_iterator last, //可以看出,共有7種構造函數

const A& al = A());

basic_string& operator=(const basic_string& rhs); //賦值運算符重載

basic_string& operator=(const E *s);

basic_string& operator=(E c); //三種賦值運算

iterator begin(); //實現(xiàn)了迭代器算法

const_iterator begin() const;

iterator end();

const_iterator end() const;

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

reverse_iterator rend();

const_reverse_iterator rend() const;

const_reference at(size_type pos) const;

reference at(size_type pos);

const_reference operator[](size_type pos) const; //下標重載

reference operator[](size_type pos);

const E *c_str() const; //返回c格式的字符串函數

const E *data() const; //.

size_type length() const; //長度大小操作

size_type size() const;

size_type max_size() const;

void resize(size_type n, E c = E());

size_type capacity() const;

void reserve(size_type n = 0);

bool empty() const;

basic_string& operator+=(const basic_string& rhs); //+=重載

basic_string& operator+=(const E *s);

basic_string& operator+=(E c);

軟件開發(fā)網

basic_string& append(const basic_string& str); //添加

basic_string& append(const basic_string& str,

size_type pos, size_type n);

basic_string& append(const E *s, size_type n);

basic_string& append(const E *s);

basic_string& append(size_type n, E c);

basic_string& append(const_iterator first, const_iterator last);

basic_string& assign(const basic_string& str); //賦值

basic_string& assign(const basic_string& str,

size_type pos, size_type n);

basic_string& assign(const E *s, size_type n);

basic_string& assign(const E *s);

basic_string& assign(size_type n, E c);

basic_string& assign(const_iterator first, const_iterator last);

basic_string& insert(size_type p0,

const basic_string& str);

basic_string& insert(size_type p0,

const basic_string& str, size_type pos, size_type n);

basic_string& insert(size_type p0,

const E *s, size_type n);

basic_string& insert(size_type p0, const E *s);

basic_string& insert(size_type p0, size_type n, E c);

iterator insert(iterator it, E c);

void insert(iterator it, size_type n, E c);

void insert(iterator it,

const_iterator first, const_iterator last);

basic_string& erase(size_type p0 = 0, size_type n = npos);

iterator erase(iterator it);

iterator erase(iterator first, iterator last);

basic_string& replace(size_type p0, size_type n0,

const basic_string& str);

basic_string& replace(size_type p0, size_type n0,

const basic_string& str, size_type pos, size_type n);

basic_string& replace(size_type p0, size_type n0,

const E *s, size_type n);

basic_string& replace(size_type p0, size_type n0,

const E *s);

basic_string& replace(size_type p0, size_type n0,

size_type n, E c);