Talk is cheap, Show me the code

0%

C++常用功能汇总-文件读写 计时 随机数

发表于 分类于
本文字数： 6.9k 阅读时长 ≈ 6 分钟

C++常用功能：文件读写 计时 随机数 等的用法

1、字符串string类

1
#include <string>
  • 常用构造函数：
1
2
3
4
5
string str;        //生成一个空字符串
string str ("ABC")  //等价于 str="ABC"<br>
string str ("ABC", strlen)  // 将"ABC"存到str里,最多存储前strlen个字节
string s("ABC",stridx,strlen)   //将"ABC"的stridx位置,做为字符串开头,存到str里.且最多存储strlen个字节.
string s(strlen, 'A')  //存储strlen个'A'到str里
  • 常用成员函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
str1.assign("ABC");　　　　　　　　//清空string串,然后设置string串为"ABC"
str1.length()；                 //获取字符串长度
str1.size();　　　　　　　　　　　 //获取字符串数量,等价于length()
str1.capacity();　　　　　　　　  //获取容量,容量包含了当前string里不必增加内存就能使用的字符数
str1.resize(10);　　　　　　     //表示设置当前string里的串大小,若设置大小大于当前串长度,则用字符\0来填充多余的.
str1.resize(10,char c);　　　　 //设置串大小，若设置大小大于当前串长度,则用字符c来填充多余的
str1.reserve(10);　　　　　　　　　//设置string里的串容量,不会填充数据.
str1.swap(str2);        　　    //替换str1 和 str2 的字符串
str1.puch_back ('A');    　　//在str1末尾添加一个'A'字符,参数必须是字符形式
str1.append ("ABC");     　　//在str1末尾添加一个"ABC"字符串,参数必须是字符串形式
str1.insert (2,"ABC");       //在str1的下标为2的位置,插入"ABC"
str1.erase(2);         　　　　//删除下标为2的位置,比如: "ABCD" --> "AB"
str1.erase(2,1);              //从下标为2的位置删除1个,比如: "ABCD"  --> "ABD"
str1.clear();           　　 //删除所有
str1.replace(2,4, "ABCD"); //从下标为2的位置,替换4个字节,为"ABCD"
str1.empty();         　　 //判断为空, 为空返回true
  • 与char*相互转换：
1
2
3
4
5
str.c_str();        //string转为char*

char *st = "hello";
string st1 = st;
string st2(st, st + strlen(st));
  • 与数字的转换：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <sstream>>
//-----------string转为数字：
istringstream iss ("123.5");    //定义对象iss,初始化为"123.5" , 
//等价于:
//istringstream iss;
//iss.str("123.5");                 //设置对象iss为"123.5" ,
double num;
 if(iss>>num)                 //通过调用iss.operator >>(num), 将"123.5"转为数字,并返回bool类型变量
    cout<<num << endl;
//也可以通过临时对象转换：
string str="123.5";
double num;
if(istringstream(str)>>num)        //通过临时对象,来将str转为数字
	cout<<num<<endl;
//或者将第3行,写为宏:
#define TO_NUM(str,num)     (istringstream(str)>>num)

//-----------数字转为string
ostringstream oss;
oss <<123.5;                   //相当于调用: oss.str("123.5");
string str= oss.str() ;
//也可以通过宏,这样写:
#define TO_STRING(num)     ( ((ostringstream&)(ostringstream()<<num)).str() )
double num=123.5;
string str= TO_STRING(123.5);

2、文件读写

文本文件读取与写入

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <fstream>
int count;
fstream inFile, outFile;
if( (_access( "in.txt", 0 )) != -1 )  
{  
	printf_s( "File crt_ACCESS.C exists.\n" );
	inFile.open("in.txt", ios::in | ios::binary);//二进制读取
}
outFile.open("out.txt", ios::out | ios::binary);//二进制写入
inFile >> count;
outFile << count;
inFile.close();
outFile.close();

文件夹相关操作

  • 判断文件夹是否存在
1
2
3
4
5
6
7
8
9
10
#include <io.h>  //Win
#include <unistd.h>

<pre name="code" class="cpp">int access(const char* _Filename, int _AccessMode)
_AccessMode:{
	#define R_OK 4 /* Test for read permission. 读权限*/
	#define W_OK 2 /* Test for write permission. 写权限*/
	#define X_OK 1 /* Test for execute permission. 是否可执行*/
	#define F_OK 0 /* Test for existence. 是否存在*/
}
  • 创建、删除文件夹
1
2
3
#include <direct.h>
int mkdir(const char *_Path)
int rmdir(const char *_Path)

函数返回0表示成功，返回-1表示失败或不存在

3、计时函数

time()

time()获取当前的系统时间，返回的结果是一个time_t类型，其实就是一个==大整数==，其值表示从CUT（Coordinated Universal Time）时间1970年1月1日00:00:00（称为UNIX系统的Epoch时间）到当前时刻的秒数。

1
2
3
4
5
6
7
8
void test1()
{
    time_t start,stop;
    start = time(NULL);
    foo();//dosomething
    stop = time(NULL);
    printf("Use Time:%ld\n",(stop-start));
}

clock()

clock()函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wal-clock）
常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元。

1
2
3
4
5
6
7
8
9
10
void test2()
{
    double dur;
    clock_t start,end;
    start = clock();
    foo();//dosomething
    end = clock();
    dur = (double)(end - start);
    printf("Use Time:%f\n",(dur/CLOCKS_PER_SEC));
}

timeGetTime()

timeGetTime()函数以毫秒计的系统时间。该时间为从系统开启算起所经过的时间,是windows api。

1
2
3
4
5
6
7
8
void test3()
{
    DWORD t1,t2;
    t1 = timeGetTime();
    foo();//dosomething
    t2 = timeGetTime();
    printf("Use Time:%f\n",(t2-t1)*1.0/1000);
}

4、随机数

cstdlib中伪随机数

C语言中通过函数rand和srand来产生伪随机数，这两个函数包含在头文件cstdlib中，其中srand用来产生设置随机数种子，rand每次返回一个当前的种子对应的随机数，这两个函数的声明如下：

1
2
void srand(unsigned seed);
int rand(void);

这两个函数的原型形如：

1
2
3
4
5
6
7
8
9
10
11
12
unsigned long int next = 1;
/* rand: return pseudo-random integer on 0..32767 */
int rand(void)
{
    next = next * 1103515245 + 12345;
    return (unsigned int)(next/65536) % 32768;
}
/* srand: set seed for rand() */
void srand(unsigned int seed)
{
    next = seed;
}

显然rand只能生成整数，需要小数时，只需要跟一个浮点数进行除法即可

一个生成[1, 15]的随机数例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <cstdlib>
#include <ctime>

//random num range is min to max, template function
template <typename T> T cRandom(int min, int max)
{
    return (min + static_cast<T>(max * rand() / static_cast<T>(RAND_MAX + 1)));
}

int main(void)
{
    srand((unsigned)time(NULL));
    //生成10个整数
    std::cout << "int: " << std::endl;
    for (int i = 0; i < 10; ++i) {
        std::cout << cRandom<int>(1, 15) << " ";
    }
    std::cout << std::endl;
    //生成10个小数
    std::cout << "double: " << std::endl;
    for (int i = 0; i < 10; ++i) {
        std::cout << cRandom<double>(1, 15) << " ";
    }
    std::cout << std::endl;
    return 0;
}

生成指定范围的随机数表达式：

  • 要取得[a,b)的随机整数，使用(rand() % (b-a))+ a;
  • 要取得[a,b]的随机整数，使用(rand() % (b-a+1))+ a;
  • 要取得(a,b]的随机整数，使用(rand() % (b-a))+ a + 1;

通用公式:a + rand() % n；其中的a是起始值，n是整数的范围。

  • 要取得a到b之间的随机整数，另一种表示：a + (int)b * rand() / (RAND_MAX + 1)。
  • 要取得0～1之间的浮点数，可以使用rand() / double(RAND_MAX)。

（2）C++11中的random类

random类是C++11中增加的类，该类可以用于生成随机数，具有C语言中rand生成伪随机数的功能，但其功能更强大。原生支持生成浮点数，及分布类。

随机数发生器主要由分布对象和随机数引擎对象组成。其中随机数引擎用于根据随机数种子来产生随机数，分布对象对产生的随机数根据需求进行分布。
random中定义了多种随机数引擎及分布类型，常用的引擎是默认伪随机数引擎类default_random_engine，常用的分布类有产生整型分布的uniform_int_distribution，产生浮点型的分布uniform_real_distribution。

输出15个double类型的随机数的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <random>
#include <iostream>
#include <ctime>

//该函数接受三个参数分别指定随机数范围和种子，返回double
double random_unint(unsigned int min, unsigned int max, unsigned int seed = 0)
{
    static std::default_random_engine e(seed);
    static std::uniform_real_distribution<double> u(min, max);
    return u(e);
}

int main(void)
{
    for (int i = 0; i < 15; ++i) {
        std::cout << random_unint(0, 15, time(NULL)) << " ";
    }
    std::cout << std::endl;
    return 0;
}

一个给定的随机数发生器一直会生成相同的随机数序列。一个函数如果定义了局部的随机数发生器，应该将其（包括引擎和分布对象）定义为static的，否则每次调用函数都会生成相同的序列。也就是说定义成static后每次调用还是之前那个发生器，第一次调用产生一批随机数，再次调用将产生接下来的随机数，否则每次调用产生的都是最前面的那些随机数。

依然需要使用time来做为种子产生每个不同时刻都不同的随机序列，但由于time默认返回的是以秒计的时间，所以有可能多次使用的都是相同的种子。

伪随机数引擎

  1. 随机数引擎支持的操作如下：
1
2
3
4
5
6
7
Engine e; //默认构造函数，使用该引擎类型的默认种子
Engine e(s); //使用整型s做为种子
e.seed(s); //使用整型s重置引擎状态
e.min(); //返回此引擎所能生成的最小和最大值
e.max();
Engine::result_type //此引擎生成的类型（unsigned）
e.discard(u); //将引擎推进u步，u为unsigned long long类型
  1. 随机数引擎使用
1
2
std::default_random_engine e;   //生成随机的无符号数
std::cout << e();       //通过()调用对象生成下一个随机数并输出

分布

  1. 分布类型有很多种，常用的有返回整型的uniform_int_distribution和返回浮点型的uniform_real_distribution
  2. 分布支持的操作
1
2
3
4
5
6
Dist d; //默认构造函数
Dist d(min, max); //为d指定范围
d(e) //e是一个随机数引擎对象
d.min() //返回d(e)所能生成的最小值和最大值
d.max()
d.reset(); //重置d的状态，使得随后对d的使用不依赖于d已经生成的值
-------------The End-------------