库函数总结

2019/04/10 10:10
阅读数 4

[TOC]

C++ cctype头文件内的判断类函数

isalpha(x) 判断大小写字母

islower(x) 判断小写字母

isupper(x) 判断大写字母

isblank(x) 判断space和\t

isspace(x) 判断(space 、\t、\r、\n)

(tolower/toupper)实现字母的大小写转换

常用到的是在ctype.h(C++中是cctype)库文件下定义的函数方法

C:

函数实现原型:
int tolower(int c)//小写
{
	if ((c >= 'A') && (c <= 'Z'))
		return c + ('a' - 'A');
	return c;
}
 
int toupper(int c)//大写
{
	if ((c >= 'a') && (c <= 'z'))
		return c + ('A' - 'a');
	return c;
}

demo-C语言实现

#include<string.h>   //strlen
#include<stdio.h>    //printf
#include<ctype.h>    //tolower
int main()
{
    int i;
    char string[] = "THIS IS A STRING";
    printf("%s\n", string);
    for (i = 0; i < strlen(string); i++)
    {
        string[i] = tolower(string[i]);
    }
    printf("%s\n", string);
    printf("\n");
}

demo-C++的实现

#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main()
{
    string str= "THIS IS A STRING";
    for (int i=0; i <str.size(); i++)
       str[i] = tolower(str[i]);
    cout<<str<<endl;
    return 0;
}

next_permutation()


对于next_permutation函数,其函数原型为:

​ #include <algorithm>

​ bool next_permutation(iterator start,iterator end)

当当前序列不存在下一个排列时,函数返回false,否则返回true

而prev_permutation函数就要反过来了,当上一个排序不存在时返回false,否则返回true

#include <iostream> 
#include <algorithm> 
using namespace std; 
int main() 
{ 
    int num[5]={1,2,3}; //此时应该是升序,中间出现逆序的会无法出现全部排序
    do 
    { 
        cout<<num[0]<<" "<<num[1]<<" "<<num[2]<<endl; 
    }while(next_permutation(num,num+3)); 
    return 0; 
} 

运行以后可以发现,next_permutation(num,num+n)函数是对数组num中的前n个元素进行全排列,同时并改变num数组的值。

另外,需要强调的是,next_permutation()在使用前需要对欲排列数组按升序排序,否则只能找出该序列之后的全排列数。

prev_premutation()与next...相反

qsort()

函数声明

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))

参数

  • **base **-- 指向要排序的数组的第一个元素的指针。
  • **nitems **-- 由 base 指向的数组中元素的个数。
  • **size **-- 数组中每个元素的大小,以字节为单位。
  • **compar **-- 用来比较两个元素的函数。

返回值

该函数不返回任何值。

#include <stdio.h>
#include <stdlib.h>

int values[] = { 88, 56, 100, 2, 25 };

int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int main()
{
   int n;

   printf("排序之前的列表:\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }

   qsort(values, 5, sizeof(int), cmpfunc);

   printf("\n排序之后的列表:\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }
  
  return(0);
}

C++ rand 与 srand 的用法

计算机的随机数都是由伪随机数,即是由小M多项式序列生成的,其中产生每个小序列都有一个初始值,即随机种子。(注意: 小M多项式序列的周期是65535,即每次利用一个随机种子生成的随机数的周期是65535,当你取得65535个随机数后它们又重复出现了。)

我们知道 rand() 函数可以用来产生随机数,但是这不是真正意义上的随机数,是一个伪随机数,是根据一个数(我们可以称它为种子)为基准以某个递推公式推算出来的一系列数,当这系列数很大的时候,就符合正态公布,从而相当于产生了随机数,但这不是真正的随机数,当计算机正常开机后,这个种子的值是定了的,除非你破坏了系统。

rand()

功能: 随机数发生器

用法:

int rand(void)
  
所在头文件:  stdlib.h

rand() 的内部实现是用线性同余法做的,它不是真的随机数,因其周期特别长,故在一定的范围里可看成是随机的。

rand() 返回一随机数值的范围在 0 至 RAND_MAX 间。RAND_MAX 的范围最少是在 32767 之间(int)。用 unsigned int 双字节是 65535,四字节是 4294967295 的整数范围。0~RAND_MAX 每个数字被选中的机率是相同的。

用户未设定随机数种子时,系统默认的随机数种子为 1。

rand() 产生的是伪随机数字,每次执行时是相同的; 若要不同, 用函数 srand() 初始化它。

srand()

功能: 初始化随机数发生器

用法:

void srand(unsigned int seed)
  
所在头文件:	stdlib.h

srand() 用来设置 rand() 产生随机数时的随机数种子。参数 seed 必须是个整数,如果每次 seed 都设相同值,rand() 所产生的随机数值每次就会一样。

使用当前时钟作为随机数种子

rand() 产生的随机数在每次运行的时候都是与上一次相同的。若要不同, 用函数 srand() 初始化它。可以利用 srand((unsigned int)(time(NULL)) 的方法,产生不同的随机数种子,因为每一次运行程序的时间是不同的。

产生随机数的用法

    1. 给srand()提供一个种子,它是一个unsigned int类型;
    1. 调用rand(),它会根据提供给srand()的种子值返回一个随机数(在0到RAND_MAX之间);
    1. 根据需要多次调用rand(),从而不间断地得到新的随机数;
    1. 无论什么时候,都可以给srand()提供一个新的种子,从而进一步"随机化"rand()的输出结果。

0~RAND_MAX 之间的随机数程序

#include <iostream>
#include <stdlib.h>
#include <time.h> 

using namespace std; 

int main()
{ 
        srand((unsigned)time(NULL)); 
        for(int i = 0; i < 10;i++ ) 
                cout << rand() << '/t';
        cout << 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)。

stringstream

stringstream 是 C++ 提供的另一个字串型的串流(stream)物件,和之前学过的 iostream、fstream 有类似的操作方式。要使用 stringstream, 必須先加入這一行:

include <sstream>

stringstream 主要是用在將一個字串分割,可以先用 clear( )以及 str( ) 將指定字串設定成一开始的內容,再用 >> 把个別的资料输出,例如:

string s;
stringstream ss;
int a, b, c;
getline(cin, s);
ss.clear();
ss.str(s);
ss >> a >> b >> c;

下面我們看到一個使用 stringstream 的例子:

題目:输入的第一行有一个数字 N 代表接下來有 N 行資料,每一行資料里有不固定個數的整數(最多 20 個,每行最大 200 個字元),請你寫一個程式將每行的总和印出來。

輸入:

3 1 2 3 20 17 23 54 77 60 111 222 333 444 555 666 777 888 999

輸出:

6 251 4995

程式如下:

string s;
stringstream ss;
int n, i, sum, a;
cin >> n;
getline(cin, s); // 讀取換行
for (i=0; i<n; i++)
{
getline(cin, s);
ss.clear();
ss.str(s);
sum=0;
while (1)
{
    ss >> a;
    if ( ss.fail() ) break;
    sum+=a;
}
cout << sum << endl;
}
					[stringstream使用详解](https://blog.csdn.net/xw20084898/article/details/21939811)

string substr()函数

string substr (size_t pos = 0, size_t len = npos) const;

产生子串

返回一个新建的

初始化为string对象的子串的拷贝

string对象。

子串是,在字符位置pos开始,跨越len个字符(或直到字符串的结尾,以先到者为准)对象的部分。

参数

pos 第一个字符的位置被复制为子串。 如果这是等于字符串的长度,该函数返回一个空字符串。 如果这是大于字符串的长度,它会抛出out_of_range。 注意:第一个字符表示为值0(不是1)。 len 字符数在子包括(如果字符串是短,尽可能多的字符可以在需要使用)。 字符串::非营利值表示的所有字符,直到字符串的结尾。

返回值

A string object with a substring of this object.

实例

#include<string>
using namespace std;
int main()
{
    string x="Hello_World";
    /*默认截取从0到npos.重载原型为string substr(_off=0,_count=npos);npos一般表示为string类中不存在的位置,_off表示字符串的开始位置,_count截取的字符的数目*/
    cout<<x.substr()<<endl;
    cout<<x.substr(5)<<endl;//截取x[5]到结尾,即npos.重载原型为string substr(_off,_count=npos)
    cout<<x.substr(0,5)<<endl;//以x[0]为始,向后截取5位(包含x[0]),重载原型string substr(_off,_count)
    /*
    备注:
    指定的截取长度加起始位置即_off+_count>源字符串的长度,则子字符串将延续到源字符串的结尾
    */
}

string append() 函数

函数原型

  basic_string &append( const basic_string &str );
  basic_string &append( const char *str );
  basic_string &append( const basic_string &str, size_type index, size_type len );
  basic_string &append( const char *str, size_type num );
  basic_string &append( size_type num, char ch );
  basic_string &append( input_iterator start, input_iterator end );

可实现的功能

在字符串的末尾添加str, 在字符串的末尾添加str的子串,子串以index索引开始,长度为len 在字符串的末尾添加str中的num个字符, 在字符串的末尾添加num个字符ch, 在字符串的末尾添加以迭代器start和end表示的字符序列.

append函数常用的三个功能:

  • 直接添加另一个完整的字符串:如str1.append(str2);
  • 添加另一个字符串的某一段子串:如str1.append(str2, 11, 7);
  • 添加几个相同的字符:如str1.append(5, ‘.’);注意,个数在前字符在后.上面的代码意思为在str1后面添加5个"."

实例

#include<bits/stdc++.h>
using namespace std;  

int main(){
    string str1="I like C++";  
    string str2=",I like the world.";  
    string str3="Hello";  
    string str4("Hi");  

    str1.append(str2);  
    str3.append(str2, 11, 7);  
    str4.append(5, '.');  
  
    cout<<str1<<endl;  
    cout<<str3<<endl;  
    cout<<str4<<endl;  
    system("pause");  
    return 0;     
}  

运行结果

I like C++,I like the world.
Hello World.
Hi.....

substr()和append()结合使用

题目描述

  • 连续输入字符串,请按长度为8拆分每个字符串后输出到新的字符串数组;
  • 长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。
实现方法1
#include<iostream>
#include<string>
using namespace std;
int main() {
	string str;
	int count = 0;
	int remain_num = 0;
	while (cin >> str) {
		count = str.size() / 8;
		remain_num = str.size() % 8;
		for (int i = 0; i < count; i++) {
			string full,temp;
			for (int j = 0; j < 8; j++) {
				temp = str[j];
				full += temp;
			}
			cout << full << endl;
			str.erase(str.begin(), str.begin() + 8);
		}
        if(remain_num){
            string remain(8-remain_num, '0');
            str += remain;
            cout << str << endl;
        }
	}
}
实现方法2

使用str.size()方法可以轻松的实现在一段字符串中提取部分内容

使用str.append()方法可以轻松实现拓展字符串

#include<iostream>
#include<string>
using namespace std;
int main() {
	string str;
	while (cin >> str) {
		int remain_num = str.size() % 8;
		while (str.size() >= 8) {
			cout << str.substr(0, 8) << endl;
			str = str.substr(8);//注意此处代表提取,从str[8]开始到str结尾的内容
		}
		if (remain_num) {
			str.append(8 - remain_num, '0');
			cout << str << endl;
		}
	}
}

C++11特性的to_string

头文件 #include<string>

to_string最常用的就是把int型变量或者数字转化为string类型

double、float也是可以的

#include<iostream>
#include<string>
using namespace std;
int main(){
  string s1=to_string(123);
  cout<<s1<<endl;
  string s2=to_string(4.5);
  cout<<s2<<endl;
  cout<<s1+s2<<endl;
  printf("%s\n",(s1+s2).c_str());//想使用printf输出string的时候要加个.c_str()
}

<br>

count函数

头文件 algorithm

功能类似于find。这个函数使用一对迭代器和一个值做参数,返回这个值出现次数的统计结果。

编写程序读取一系列int型数据,并将它们存储到vector对象中,然后统计某个指定的值出现了多少次。

cout<<count(ivec.begin() , ivec.end() , searchValue)

具体实现:

//读取一系列int数据,并将它们存储到vector对象中,  
//然后使用algorithm头文件中定义的名为count的函数,  
//统计某个指定的值出现了多少次  
#include<iostream>  
#include<vector>  
#include<algorithm>  
using namespace std;  

int main()  
{  
    int ival , searchValue;  
    vector<int> ivec;  

    //读入int型数据并存储到vector对象中,直至遇到文件结束符  
    cout<<"Enter some integers(Ctrl+Z to end): "<<endl;  
    while(cin >> ival)  
        ivec.push_back(ival);  

    cin.clear(); // 使输入流重新有效  

    //读入欲统计其出现次数的int值  
    cout<<"Enter an integer you want to search: "<<endl;  
    cin>>searchValue;  

    //使用count函数统计该值出现的次数并输出结果  
    cout<<count(ivec.begin() , ivec.end() , searchValue)  
        <<"  elements in the vector have value "  
        <<searchValue<<endl;  

    return 0;  
}  

count_if函数

count_if :返回区间中满足指定条件的元素数目。

template

#include <vector>  
#include <algorithm>  
#include <iostream>  

bool greater10(int value)  
{  
    return value >10;  
}  

int main()  
{  
    using namespace std;  
    vector<int> v1;  
    vector<int>::iterator Iter;  

    v1.push_back(10);  
    v1.push_back(20);  
    v1.push_back(10);  
    v1.push_back(40);  
    v1.push_back(10);  

    cout << "v1 : ";  
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)  
       cout << *Iter << " ";  
    cout << endl;  


    vector<int>::size_type  result1 = count_if(v1.begin(), v1.end(), greater10);  //count_if算法返回使谓词函数返回条件成立的元素个数  
    cout << "The number of elements in v1 greater than 10 is: "  
         << result1 << "." << endl;  

    return 0;  
}  

谓词(predicate):是做某些检测的函数,返回用于条件判断的类型,指出条件是否成立。 总结: count : 在序列中统计某个值出现的次数

count_if : 在序列中统计与某谓词匹配的次数

greater()与less()函数

greater和less是头文件<functional>中定义的两个结构,它们通过重载了()运算符来实现比较功能。

greater的定义如下:

template <class T> struct greater {
  bool operator() (const T& x, const T& y) const {return x>y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

less的定义如下:

template <class T> struct less {
  bool operator() (const T& x, const T& y) const {return x<y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

具体使用

#include<iostream>
#include<algorithm>//因为用了sort()函数
#include<functional>//因为用了greater<int>()
using namespace std;
 
void main()
{
	int a[]={3,1,4,2,5};
	int i;
	int len=sizeof(a)/sizeof(int);//这里切记要除以sizeof(int)!

	sort(a ,a + len, greater<int>());//内置类型的由大到小排序
	for(i=0;i<len;i++)
		cout<<a[i]<<" ";
	cout<<"\n";
	sort(a, a + len, less<int>());//内置类型的由小到大排序
	for(i=0;i<len;i++)
		cout<<a[i]<<" ";
}

priority_queue用法

头文件 : #include<queue>
定义: priority_queue<int> p;

优先输出大数据

priority_queue<Type, Container, Functional>

Type为数据类型, Container为保存数据的容器,Functional为元素比较方式。

如果不写后两个参数,那么容器默认用的是vector,比较方式默认用operator<,也就是优先队列是大顶堆,队头元素最大。

举例:
#include<iostream>
#include<queue>
using namespace std;
 
int main(){
	priority_queue<int> p;
	p.push(1);
	p.push(2);
	p.push(8);
	p.push(5);
	p.push(43);
	for(int i=0;i<5;i++){
		cout<<p.top()<<endl;
		p.pop();
	}
	return 0;
}

优先输出小数据

方法一
priority_queue<int, vector<int>, greater<int> > p;

举例

#include<iostream>
#include<queue>
using namespace std;
 
int main(){
	priority_queue<int, vector<int>, greater<int> >p;
	p.push(1);
	p.push(2);
	p.push(8);
	p.push(5);
	p.push(43);
	for(int i=0;i<5;i++){
		cout<<p.top()<<endl;
		p.pop();
	}
	return 0;
}

方法二:自定义优先级,重载默认的 < 符号

举例:

#include<iostream>
#include<queue>
#include<cstdlib>
using namespace std;
struct Node{
	int x,y;
	Node(int a=0, int b=0):
		x(a), y(b) {}
};
 
struct cmp{
	bool operator()(Node a, Node b){
		if(a.x == b.x)	return a.y>b.y;
		return a.x>b.x;
	}
};
 
int main(){
	priority_queue<Node, vector<Node>, cmp>p;
	
	for(int i=0; i<10; ++i)
		p.push(Node(rand(), rand()));
		
	while(!p.empty()){
		cout<<p.top().x<<' '<<p.top().y<<endl;
		p.pop();
	}//while
	//getchar();
	return 0;
}


STL适合场景

vector deque list set mulitset map mulitmap
内存结构 单端数组 双端数组 双向链表 二叉树 二叉树 二叉树 二叉树
可随机存储 对key而言,不是
元素搜索速度 非常慢 对key而言,快 对key而言,快
元素插删位置 尾端 头尾两端 任何位置 --- --- --- ---

list 表单 vector 顺序方面元素 deque 队列 map 关键字-值,字典 set 在文本处理过程中,可以用来保存想要忽略的单词。


isdigit()检查所传的字符是否是十进制数字字符

描述

C 库函数 void isdigit(int c) 检查所传的字符是否是十进制数字字符。

十进制数字是:0 1 2 3 4 5 6 7 8 9

函数声明

int isdigit(int c);

返回值: 如果 c 是一个数字,则该函数返回非零值,否则返回 0。
实例
#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'h';
   int var2 = '2';
    
   if( isdigit(var1) )
   {
      printf("var1 = |%c| 是一个数字\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 不是一个数字\n", var1 );
   }
   if( isdigit(var2) )
   {
      printf("var2 = |%c| 是一个数字\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 不是一个数字\n", var2 );
   }
  
   return(0);
}

结果

var1 = |h| 不是一个数字
var2 = |2| 是一个数字

stoi 函数解析

功能

将 n 进制的字符串转化为十进制

用法

stoi(字符串,起始位置,n进制),将 n 进制的字符串转化为十进制
 
示例:
stoi(str, 0, 2); //将字符串 str 从 0 位置开始到末尾的 2 进制转换为十进制

头文件

#include <string>

实例

#include <iostream>
#include <string>
 
using namespace std;
 
int main()
{
	string str = "1010";
	
	int a = stoi(str, 0, 2);
 
	cout << a << endl;
}

//输出10

iota函数

函数原型

template <class ForwardIterator, class T>
  void iota (ForwardIterator first, ForwardIterator last, T val);

等价于
template<class _FwdIt,class _Ty> inline
    void _Iota(_FwdIt _First, _FwdIt _Last, _Ty _Val)
{   // compute increasing sequence into [_First, _Last)
    for (; _First != _Last; ++_First, ++_Val)
        *_First = _Val;
}
参数:
  • first,last:

    分别指向序列中初始及末尾位置的正向迭代器(Forward Iterators)。这个范围即 [first,last) ,包括 first 到 last 间的所有元素,包括 first 指向的元素,但不包括 last 指向的元素。

  • val:用于累加的初始值。

功能

用顺序递增的值赋值指定范围内的元素 。

实例

// iota example
#include <iostream>     // std::cout
#include <numeric>      // std::iota

int main () {
  int numbers[10];

  std::iota (numbers,numbers+10,100);

  std::cout << "numbers:";
  for (int& i:numbers) std::cout << ' ' << i;
  std::cout << '\n';

  return 0;
}
numbers: 100 101 102 103 104 105 106 107 108 109

原文出处:https://www.cnblogs.com/RioTian/p/12329707.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部