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结尾的文件,而现在的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);

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