命名空间
标准库的命名空间
1 #include <iostream> 2 #include <string> 3 using std::cout; 4 using std::cin; 数组和指针
数组声明时候的下标类型
整型常量 枚举常量 整型const常量
指针声明应该注意的
1 string* s1, s2;
s2 不是指针的了
安全声明方式为
1 string *s1, s2;
关于NULL
从C语言继承下来的 在cstdlib中定义的 不属于标准控件
std::NULL 是错误的
void 指针
void指针只能读 不要写 不允许赋值
C++支持指针相减
1 ptrdiff_t p1 – p2;
返回类型是 ptrdiff_t 和 size_t 类似 与机器相关
只不过ptrdiff_t 是signed整型
在文件 cstddef中定义
指针的下标可以为负数
因为指针的下标表示的就是加减的含义
1 int *p = &ia[2];
2 int k = p[-2]; // 正确 相当于 *(p - 2)
指针是数组的迭代器
1 const size_t arr_sz = 5;
2 int int_arr[arr_sz] = {0, 1, 2, 3, 4};
3 for(int *pbegin = int_arr, *pend = int_arr + arr_sz; pbegin != pend; pbegin++)
4 {
5 cout<<*pbegin<<endl;
6 }
指针和const
1 // 指针常量 指针指向的单元不能修改 const修饰的是int *p
2 const int *p;
3 int const *p;
这种指针只能指向任何对象 但是const对象的地址也只能赋给const 指针
虽然可以指向任何对象 一旦指向了某对象就不能通过该指针的解引用修改对象的值
4 // 常量指针 指针本身不能修改 const修饰的是 p
5 int *const p;
这种情况下 解引用的值是可以改变的
typedef的情况
1 typedef string *pstring;
2 const pstring cstr;
const 修饰的是cstr 所以等价于 string * const cstr
字符串操作
strlen是不包括NULL在内的字符串的长度
new出来数组
1 int *p = new int[10]; 2 delete [] p; c语言数组和string混合
1 char * sz = “abcdef”; 2 string str1(sz); 3 string str2; 4 str2 = sz; 5 str2 = str1 + sz; 也可以获得string的c方式存储
因为返回的是const char*所以定义必须是const char*
1 const char *sz = str.c_str(); 数组可以初始化vector
1 const size_t arr_size = 4; 2 int sz[arr_size] = {0, 1, 2, 3}; 3 vector<int> ivec(sz + 1, sz + arr_size); 多维数组
多维数组实际上就是数组的数组
1 int a[3][4]; // 数组有3个元素 每个元素是 int[4]的数组 2 int (*p)[4]; // 指向4个单元元素的数组指针 3 p = &a[2]; // 表明p指向a二维数组的第三个元素 typedef定义指向数组的指针
1 int ia[3][4]; 2 typedef int int_array[4] 3 int_array *ip = ia; 4 for(int_array *p = ia; p != ia + 3; p++) 5 { 6 for(int *q = *p; q != *p + 4; q++) 7 { 8 cout<<*q<<endl; 9 } 10 } 标准库string类型
c语言是 string.h
c++库是cstring.h
1 #include <string> 2 using std::string; 初始化
1 string s1; 2 string s2(s1); 3 string s3("value"); 4 string s4(n, 'c'); 输入输出
1 while(cin>>word) 2 { 3 cout<<word<<endl; 4 } 输入时会过滤字符串前面的空格
遇到空格时输入完毕
输入一行
1 string s; 2 while(getline(cin, s)) 3 { 4 cout<<s<<endl; 5 } getline是以换行符为标准的 遇到换行符就停止输入
string对象的操作
1 s.empty(); // 判断字符串是否为空 2 s.size(); // 字符个数 这里的返回值是 string::size_type string 库里定义的类型 不能赋值给int 但是可以赋值给unsigned 3 s[n]; // 从0开始的第n个字符 既可以输入也可以输出 4 s1 + s2; // 还有+=操作符 5 s1 = s2; 6 v1 == v2 // >= <= == != > < 采用的是字典序 unsigned int 和 unsigned long 表示的是一样的意思
+是可以连着加的，但是+左右必须至少有一个是string类型的
1 s3 = "Hello" + "world"; // error 2 s4 = s1 + "Hello" + "world"; // OK 3 s4 = "Hello" + "world" + s1; // error 最后一个字符是
1 s[s.size - 1]; // 因为是从0开始的下标 输出每一个字符
1 for(string::size_type i = 0; i != s.size(); i++) 2 { 3 cout<<s[i]<<endl; 4 } 也可以输入
1 s[0] = 'a'; 索引的范围是 0倒s.size() – 1
string为空的时候size()是0
索引的类型是 unsigned 的 string::size_type
string 还可以对其中的单个字符 进行判断处理
这些函数在 cctype 头文件中加以定义
cctype.h 和 ctype.h 是一样的
只是一个是cpp 方式定义的 还有命名空间 std 一个是 c 方式定义的
也
标准库vector类型
容器类型 模板
1 #include <vector> 2 using std::vector; vector本身是一个类型 用来定义对象
1 vector<int> ivec; 初始化
1 vector<int> ivec1; // 初始化为空 empty 2 vector<int> ivec2(ivec1); // 用一个初始化另一个 3 vector<int> ivec3(10, -1); // 初始化10个元素 每一个为-1 4 vector<int> ivec4(10); // 初始化10个元素 每一个为默认值 这里为0 vector本身初始化的 虽然有初始化 但通常是定义一个空的对象 然后动态增长
操作
1 v.empty(); // 判断空否 2 v.size(); // 获取元素个数 3 v[n]; // 和string类似 4 v1 = v2; // 赋值 5 v1 == v2; // 判断相等 > < != >= <= 6 v.push_back(t); // 末尾加入元素 虽然size返回的也是size_type 但要注意类型
1 vector<int>::size_type; // OK 2 vector::size_type; // error
一个push_back的例子
1 #include <string> 2 #include <vector> 3 using std::string; 4 using std::vector; 5 6 string word; 7 vector<string> text; 8 while(cin>>word) 9 { 10 text.push_back(word); 11 } 为什么在循环体中每次都调用size() 而不是调用一次 保存size的值每次都使用呢
因为很多类型的size都是动态增长的 所以这么做才是合理的
为什么用 != 作为判断循环的结束 而不是 < 之类的呢
迭代器
迭代器可以起到和下标一样的功能 可以对容器中的元素进行操作
下标操作只有少数容器支持 迭代器对于所有的容器都可以支持
要使用迭代器 首先要定义该容器下的迭代器变量
1 vector<int>::iterator iter;
容器的位置获取
1 vector<T>::iterator vector::begin(); 2 vector<T>::iterator vector::end();
返回值是迭代器类型哦~
1 vector<int> ivec; 2 ivec.begin(); // 指向第一个元素 ivec[0]的位置 3 ivec.end(); // 指向最后一个元素的 后一个元素 这是一个不存在的元素 如果为空
1 ivec.begin() == ivec.end(); 迭代器操作
1 vector<T>::iterator iter; 2 3 iter++ ++iter 4 iter-- --iter 5 *iter // 相当于ivec[]操作 也可以被赋值 6 iter + n; // 返回该容器的iterator类型 n 是该容器的size_type 类型 或者 difference_type 类型 7 iter – n; // 返回该容器的iterator类型 n 是该容器的size_type 类型 或者 difference_type 类型 8 iter1 – iter2; // 返回difference_type 类型 difference_type类型和size_type类型唯一不同在于它是signed的
例子
1 for(vector<T>::iterator iter = ivec.begin(); iter != ivec.end(); iter++) 2 { 3 *iter = 0; 4 } 对于*iter 有const_iterator这样的迭代器类型的变量 *iter的时候 不能改写变量
标准库bitset类型
1 #include <bitset> 2 using std::bitset; 定义
1 bitset<32> b; // 默认每一个位都是0 初始化
1 bitset<n> b; // 初始化一个元素 每一位都是0 2 bitset<n> b(u); // 用unsigned初始化 直接拷贝 低位保留 高位补0 或者截断 3 bitset<n> b(s); // 用string类型初始化 string的值必须是像“10101010101”这样的 string的低位被截断了 4 bitset<n> b(s, pos); // 用string类型初始化 从string型的 pos位置开始到string::size() - 1 5 bitset<n> b(s, pos, n); // 用string类型初始化 从string型的 pos位置开始到 pos + n 高低位的顺序
1 bitset<32> b; b[31],b[30],…,b[0]
而string型是 s[0],s[1],…,s[s.size() - 1]
函数
默认实参
可以在函数声明中采用默认实参
也可以在函数实现中采用
但是2者只能取其一
如果在函数实现中采用的话 应当包含源文件 否则默认实参是无效的
静态局部变量
1 static int a; 在函数生命期外仍然有效
但是函数外部无法访问到
下次调用该函数的时候
该数据还存在
内联函数
产生原因
和单纯写语句相比，写成函数的方式
好理解 好改 好重用 好统一 但是比语句要慢
内联好处
在内联处展开 效率高
在头文件中声明
1 inline int fun(); 在函数体中实现
1 inline int fun() 2 { 3 } 宏不能访问对象的私有成员。
宏的定义很容易产生二意性。
