ISO C++基本类型和变量

时间：2009-08-04

　　基本类型和变量.

　　像其他语言一样,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结尾的文件,而现在的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机制更复杂,主要就是他定义了一组权限规则,private,protected,public.(记得类后面有;号啊)struct内部的成员都是public属性.

　　C++标准库(STL)

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

　　现在我们来玩玩string这个东东.这个东东在pascal里也有,内存分配是引用计数 +Length + ansichar*,在string里,在C++里只知道是一个常用对象,具体怎么分配的,网上好多垃圾也没有说清楚.只说什么copyonwrite乱七八糟之云乎.既然是类,那么就要遵循C++实例规则.C++没有pascal那么严格,pascal里只有明确的create才能创造对象,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);用另一个字符串的一节去构造

　　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(); //实现了迭代器算法

　　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);

　　软件开发网

　　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);