字符串 on ZRJ | 学习笔记

strncpy 的用法

Tue, 27 Aug 2013 09:39:21 +0800

在官方的文档中，http://www.cplusplus.com/reference/cstring/strncpy/，例程的 strncpy 的用法是：

/* strncpy example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str1[]= "To be or not to be";
  char str2[40];
  char str3[40];

  /* copy to sized buffer (overflow safe): */
  strncpy ( str2, str1, sizeof(str2) );

  /* partial copy (only 5 chars): */
  strncpy ( str3, str2, 5 );
  str3[5] = '\0';   /* null character manually added */

  puts (str1);
  puts (str2);
  puts (str3);

  return 0;
}

注意到第 12 行，最后的参数是直接 sizeof，这样虽然可以防止溢出，但是其实还是 printf strlen 之类的不安全的，看看这个例子：

#include <stdio.h>
#include <string.h>

int main() {
    char str[3];
    memset(str, 0, sizeof(str));
    strncpy(str, "testtest", sizeof(str));
    printf("[%s][%d]\n", str, strlen(str));
    return 0;
}

看看输出：

$ ./a.out 
[tes][6]
$ ./a.out 
[tesx][6]
$ ./a.out 
[tesn][6]
$ ./a.out 
[tes][6]
$ ./a.out 
[tes][6]
$ ./a.out 
[tes*][6]
$ ./a.out 
[tes¡][6]
$ ./a.out 
[tesP][6]
$ ./a.out 
[tes][6]

可以看到，最后那个 char 是不确定的，而且 strlen 也出错，那么，稳妥的做法应该是 -1

#include <stdio.h>
#include <string.h>

int main() {
    char str[3];
    memset(str, 0, sizeof(str));
    strncpy(str, "testtest", sizeof(str)-1);
    printf("[%s][%d]\n", str, strlen(str));
    return 0;
}

$ ./a.out 
[te][2]
$ ./a.out 
[te][2]
$ ./a.out 
[te][2]
$ ./a.out 
[te][2]

这样才能有稳定的输出

历史评论

ZRJ (2013-09-29 21:13:02):

而另外，snprintf 则不需要 - 1

ZRJ (2014-01-27 17:17:24):

http://stackoverflow.com/questions/12275381/strncpy-vs-sprintf

字符串转浮点数

Sun, 14 Oct 2012 18:59:17 +0800

今天看到一个题，让把字符串转成浮点数，列了一下，需要注意的应该就是这几点

前导空白字符
符号位
前导零

#include <stdio.h>
#include <string.h>
#include <math.h>

double a2f(char *str) {
	// leading space
	while (*str==' ' || *str=='t') {
		str++;
	}

	// judge sign
	int sign = 1;
	if (*str == '-') {
		sign = -1;
		str++;
	} else if (*str=='+') {
		sign = 1;
		str++;
	} else if (*str>='0' && *str<='9') {
		sign = 1;
	} else {
		// exception
		return 0;
	}

	// leading zero
	while (*str == '0') {
		str++;
	}

	int integer=0, decimals=0, e=0;
	int point_found = 0;
	for (; *str!='\0'; str++) {
		if (*str>='0' && *str<='9') {
			if ( ! point_found) {
				integer = integer*10 + (*str-'0');
			} else {
				decimals = decimals*10 + (*str-'0');
				e++;
			}
		} else if (*str == '.') {
			if ( ! point_found) {
				point_found = 1;
			} else {
				// exception
				return 0;
			}
		} else {
			// exception
			return 0;
		}
	}

	return sign*(integer+decimals*pow(10, e*-1.0));
}

int main() {
	printf("%lfn", a2f("-000123.45600"));
	return 0;
}

==================================

2012-10-14 19:18:25 update 哦，对了，上面的代码没有考虑浮点溢出

字符串距离

Sat, 13 Oct 2012 18:26:16 +0800

今天见到一个题，让求两个字符串之间的距离，隐约记得之前在 php 中用过这个的现成函数，当时还查了一下原理，是一个俄罗斯的人搞的一个算法，原理是用矩阵，于是就往矩阵上去想，结果没想出来，后来听同学说那是个 dp，想想也是，唉，思路狭隘了

参考这里，http://www.java3z.com/cwbwebhome/article/article5/51329.html?id=4197，写了一个矩阵的版本，写的时候注意一下二维数组的操作

#include <stdio.h>
#include <string.h>

inline int min(int a, int b, int c) {
	if (a<=b && a<=c) {
		return a;
	} else if (b<=a && b<=c) {
		return b;
	} else {
		return c;
	}
}

int ld(char *str1, char *str2) {
	int len1=strlen(str1), len2=strlen(str2);
	if (len1 == 0) {
		return len2;
	}
	if (len2 == 0) {
		return len1;
	}
	int **d;

	// create 2d array
	d = new int*[len1+1];
	for (int i=0; i<len1+1; i++) {
		d[i] = new int[len2+1];
	}

	// init 2d array
	for (int i=0; i<len1+1; i++) {
		d[i][0] = i;
	}
	for (int i=0; i<len2+1; i++) {
		d[0][i] = i;
	}

	// Levenshtein distance
	for (int i=1; i<=len1; i++) {
		for (int j=1; j<=len2; j++) {
			int is_diff = 0;
			if (str1[i-1] == str2[j-1]) {
				is_diff = 0;
			} else {
				is_diff = 1;
			}
			d[i][j] = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+is_diff);
		}
	}
	int ans = d[len1][len2];

	// delete 2d array
	for (int i=0; i<len1+1; i++) {
		delete[] d[i];
	}
	delete[] d;
	d = NULL;

	return ans;
}

int main() {
	char str1[] = "bambol";
	char str2[] = "umbo";
	printf("%dn", ld(str1, str2));
	return 0;
}

可以看到说是矩阵其实还是有 dp 的影子的

字符串反转

Sat, 13 Oct 2012 17:13:39 +0800

今天遇到一个题，让反转字符串，简单题，注意下细节就好了

#include <stdio.h>
#include <string.h>

char *str_reverse(char *str) {
	if (str == NULL) {
		return NULL;
	}
	for (char *left=str, *right=str+strlen(str)-1;
		left<right; left++, right--) {
		char tmp = *left;
		*left = *right;
		*right = tmp;
	}
	return str;
}

int main() {
	char str[] = "123456";
	printf("%sn", str_reverse(str));
	return 0;
}

找出第一个不重复的字母

Mon, 24 Sep 2012 20:01:01 +0800

今天笔试，遇到一个题目要找出一个字符串中第一个不重复的字母，简单写了一下

#include <stdio.h>

void find(const char *str, char *result)
{
	int count[128]={0}, pos[128]={0};
	for (int i=0; str[i]!='\0'; i++)
	{
		int ascii = (int)(str[i]);
		count[ascii]++;
		if (pos[ascii] == 0)
		{
			pos[ascii] = i;
		}
	}
	int min = 99999;
	for (int i=0; i<128; i++)
	{
		if (count[i] == 1 && pos[i]<min)
		{
			*result = (char)i;
			min = pos[i];
		}
	}
}

int main()
{
	char *str = "teeter";
	char result;
	find(str, &result);
	printf("%cn", result);
	return 0;
}

输出一个字符串的组合

Thu, 13 Sep 2012 18:36:10 +0800

跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归

#include <stdio.h>
#include <string.h>

void combine(char str[], int str_index, char res_total, char result[], int res_index)
{
	if (res_total == res_index)
	{
		for (int i=0; i<res_total; i++)
		{
			printf("%c ", result[i]);
		}
		printf("n");
	}
	else if (str_index==strlen(str))
	{
		return;
	}
	else
	{
		result[res_index] = str[str_index];
		combine(str, str_index+1, res_total, result, res_index+1);
		combine(str, str_index+1, res_total, result, res_index);
	}
}

int main()
{
	char str[100];
	char result[100];
	scanf("%s", str);
	for (int i = 1; i<=strlen(str); i++)
	{
		combine(str, 0, i, result, 0);
	}
	return 0;
}

输入输出

abcd
a
b
c
d
a b
a c
a d
b c
b d
c d
a b c
a b d
a c d
b c d
a b c d

可以发现没有考虑去重的情况，这个应该比较容易，就是预处理扫一遍，如果是 ascii 字符的话，那么把输入的 str 映射要一个位图上就可以了。

KMP 串匹配

Thu, 13 Sep 2012 16:55:51 +0800

昨天一天没有写出代码来，惭愧惭愧，昨天在看红黑树和堆排序，可惜最后都没有能写出东西来，渐渐的感觉网络上的中文资料不太可以依赖了啊，要么就是没有，要么就是 google 出来排名在前面的都会写错，看来要么转向英文资料，要么转向纸质书了

今天参考这里，http://blog.csdn.net/v_july_v/article/details/7041827，写了个 KMP 串匹配，感觉 KMP 也是网络上的中文资料好多错的，而且讲的也繁杂，看了好久都没有能够讲清楚

#include <iostream>
#include <string>

using namespace std;

int kmp(const string &target, const string &pattern)
{
	const int tar_len = target.size();
	const int pat_len = pattern.size();

	// 构造 next 数组
	int *next = new int[pat_len];
	next[0] = -1;
	int index = 0;
	for (int i=1; i<pat_len; i++)
	{
		index = next[i-1];
		while (index>=0 && pattern[index+1]!=pattern[i])
		{
			index = next[index];
		}
		if (pattern[index+1] == pattern[i])
		{
			next[i] = index + 1;
		}
		else
		{
			next[i] = -1;
		}
	}

	// KMP 匹配
	int par_index = 0;
	int tar_index = 0;
	while (par_index<pat_len && tar_index<tar_len)
	{
		if (target[tar_index] == pattern[par_index])
		{
			tar_index++;
			par_index++;
		}
		else if (par_index == 0)
		{
			tar_index++;
		}
		else
		{
			par_index = next[par_index-1] + 1;
		}
	}

	delete[] next;

	if(par_index == pat_len)
	{
		return tar_index-par_index;
	}
	else
	{
		return -1;
	}
}

int main()
{
	string target = "ababc";
	string pattern = "abc";
	cout<<kmp(target, pattern)<<endl;
	return 0;
}

输入输出