Dutor » 字符串 http://www.dutor.net 熟读而精思，循序而渐进，厚积而薄发。 Tue, 17 Jan 2012 14:44:19 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 内存泄漏小陷阱 http://www.dutor.net/index.php/2009/11/mem-leak-trap/ http://www.dutor.net/index.php/2009/11/mem-leak-trap/#comments Wed, 18 Nov 2009 04:36:20 +0000 dutor http://www.dutor.net/?p=1681 int main() { char * str = new char[32]; str = "Hello, Piggy!"; return 0; } 这样是会内存泄漏的……而我一直都不知道……不过想来也自然，因为这样是允许的，char *str = "Hello, Piggy!";，“程序中的字符串被存放在常量存储区”不要把这句话当成耳旁风，谨记。]]> 
1
2
3
4
5
6
7

int
main()
{
	char * str = new char[32];
	str = "Hello, Piggy!";
	return 0;
}

这样是会内存泄漏的……而我一直都不知道……

1
2
3
4
5
6
7
8
9
10
11
12

.LC0:
	.string	"Hello, Piggy!"
	.text
.globl main
	.type	main, @function
main:
	andl	$-16, %esp
	subl	$32, %esp
	movl	$32, (%esp)
	call	_Znaj
	movl	%eax, 28(%esp)
	movl	$.LC0, 28(%esp) ;把str给覆盖了

不过想来也自然，因为这样是允许的，char *str = “Hello, Piggy!”;，“程序中的字符串被存放在常量存储区”不要把这句话当成耳旁风，谨记。

]]> http://www.dutor.net/index.php/2009/11/mem-leak-trap/feed/ 10 常用的几个字符串Hash函数 http://www.dutor.net/index.php/2009/11/string-hash/ http://www.dutor.net/index.php/2009/11/string-hash/#comments Tue, 17 Nov 2009 07:47:11 +0000 dutor http://www.dutor.net/?p=1670 // SDBM Hash Function unsigned int SDBMHash (char *str) { unsigned int hash = 0; while (*str) { hash = (*str++) + (hash << 6) + (hash << 16) - hash; } return (hash & 0x7FFFFFFF); } ]]> 
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// RS Hash Function
unsigned int
RSHash (char *str)
{
    unsigned int b = 378551;
    unsigned int a = 63689;
    unsigned int hash = 0;
    while (*str)
      {
	  hash = hash * a + (*str++);
	  a *= b;
      }
    return (hash & 0x7FFFFFFF);
}
 
// JS Hash Function
unsigned int
JSHash (char *str)
{
    unsigned int hash = 1315423911;
    while (*str)
      {
	  hash ^= ((hash << 5) + (*str++) + (hash >> 2));
      }
    return (hash & 0x7FFFFFFF);
}
 
// P. J. Weinberger Hash Function
unsigned int
PJWHash (char *str)
{
    unsigned int BitsInUnignedInt = (unsigned int) (sizeof (unsigned
							    int) * 8);
    unsigned int ThreeQuarters = (unsigned int) ((BitsInUnignedInt * 3) / 4);
    unsigned int OneEighth = (unsigned int) (BitsInUnignedInt / 8);
    unsigned int HighBits = (unsigned int) (0xFFFFFFFF) <<
	(BitsInUnignedInt - OneEighth);
    unsigned int hash = 0;
    unsigned int test = 0;
    while (*str)
      {
	  hash = (hash << OneEighth) + (*str++);
	  if ((test = hash & HighBits) != 0)
	    {
		hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
	    }
      }
    return (hash & 0x7FFFFFFF);
}
 
// ELF Hash Function
unsigned int
ELFHash (char *str)
{
    unsigned int hash = 0;
    unsigned int x = 0;
    while (*str)
      {
	  hash = (hash << 4) + (*str++);
	  if ((x = hash & 0xF0000000L) != 0)
	    {
		hash ^= (x >> 24);
		hash &= ~x;
	    }
      }
    return (hash & 0x7FFFFFFF);
}
 
// BKDR Hash Function
unsigned int
BKDRHash (char *str)
{
    unsigned int seed = 131;	// 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;
    while (*str)
      {
	  hash = hash * seed + (*str++);
      }
    return (hash & 0x7FFFFFFF);
}
 
// SDBM Hash Function
unsigned int
SDBMHash (char *str)
{
    unsigned int hash = 0;
    while (*str)
      {
	  hash = (*str++) + (hash << 6) + (hash << 16) - hash;
      }
    return (hash & 0x7FFFFFFF);
}
 
// DJB Hash Function
unsigned int
DJBHash (char *str)
{
    unsigned int hash = 5381;
    while (*str)
      {
	  hash += (hash << 5) + (*str++);
      }
    return (hash & 0x7FFFFFFF);
}
 
// AP Hash Function
unsigned int
APHash (char *str)
{
    unsigned int hash = 0;
    int i;
    for (i = 0; *str; i++)
      {
	  if ((i & 1) == 0)
	    {
		hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
	    }
	  else
	    {
		hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
	    }
      }
    return (hash & 0x7FFFFFFF);
}

　　对最简单的SDBMHash(char*)做了一个简单的测试。随机生成200个长度为31的字符串，利用SDBM得到一个Hash值，然后用直接取余法插入长度为113的HashSet，为简单起见，只是将HashSet对应的位置进行加一。

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
28
29
30
31

 
const int N = 32;
char str[N];
int HashSet[113] = {0};
void RandStr(char* str, const int n)
{
	int i = 0;
	for( ; i < n - 1; ++i)
	{
		str[i] = 'a' + rand() % 26;
	}
	str[i] = '\0';
}
 
int main()
{
	srand(time(NULL));
	const int count = 200;
	for(int i = 0; i < count; ++i)
	{
		RandStr(str, N);
		HashSet[SDBMHash(str)%113]++;
	}
	FILE* out = fopen("./result.txt", "w");
	//~ FILE* out = stdout;
	for(int i = 0; i < 113; ++i)
	{
		fprintf(out, "%d\n", HashSet[i]);
	}
	return 0;
}

　　测试效果还是很不错的，相当均匀了已经。

HashTest Diagram

HashTest Diagram

]]> http://www.dutor.net/index.php/2009/11/string-hash/feed/ 0 A question from csdn-关于字符串、单词 http://www.dutor.net/index.php/2009/08/a-question-from-csdn/ http://www.dutor.net/index.php/2009/08/a-question-from-csdn/#comments Sun, 16 Aug 2009 05:45:24 +0000 dutor http://www.dutor.net/?p=1087 一种遍历算法 
int main()
{
    string word;
    cin>>word;
    int len = word.length()-1;
    long psb = 1;
    for (int i = 0;i < len;i++)
    {
        psb *= 2;
    }
    int *flags = new int[len];
    for (int i = 0;i < psb;i++)
    {
        int temp = i;
        for (int j = 0;j < len;j++)
        {
            flags[j] = temp%2;
            temp = temp/2;
        }
        if(i>0)
        {
            for (int j = 0;j < len;j++)
            {
                cout<]]>
			问题描述

一个单词，可以在其相临的两个字母中插入一个“-”（横杠字符）而形成一个字符串，比如单词cake，可以在相连字母间（不同的位置）拖入“-”，而得到如下字符串：



c-a-k-e

ca-k-e

cak-e

c-ak-e

c-ake

ca-ke

c-a-ke



如果给定任一个单词（作为输入），按上面的规则，在其相临的两个字母中插入一个“-”，要计算出所有可能的形成的字符串（输出），程序要怎么写？


又例如输入单词 cat，输出结果为：



c-a-t

ca-t

c-at



一种遍历算法



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
28
29
30
31
32
33
34
35

#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    string word;
    cin>>word;
    int len = word.length()-1;
    long psb = 1;
    for (int i = 0;i < len;i++)
    {
        psb *= 2;
    }
    int *flags = new int[len];
    for (int i = 0;i < psb;i++)
    {
        int temp = i;
        for (int j = 0;j < len;j++)
        {
            flags[j] = temp%2;
            temp = temp/2;
        }
        if(i>0)
        {
            for (int j = 0;j < len;j++)
            {
                cout<<word[j];
                if(flags[j] == 1)cout<<"-";
            }
            cout<<word[word.length()-1]<<endl;
        }
    }
}


]]>
			http://www.dutor.net/index.php/2009/08/a-question-from-csdn/feed/
		0
		
		
		两片代码
		http://www.dutor.net/index.php/2009/08/two-code/
		http://www.dutor.net/index.php/2009/08/two-code/#comments
		Mon, 03 Aug 2009 08:25:05 +0000
		dutor
				
		
		
		

		http://www.dutor.net/?p=1007
		char * strstr(const char*, const char*)

/**
 * strstr - Find the first substring in a %NUL terminated string
 * @s1: The string to be searched
 * @s2: The string to search for
 */
char *strstr(const char *s1, const char *s2)
{
	int l1, l2;

	l2 = strlen(s2);
	if (!l2)
		return (char *)s1;
	l1 = strlen(s1);
	while (l1 >= l2) {
		l1--;
		if (!memcmp(s1, s2, l2))
			return (char *)s1;
		s1++;
	}
	return NULL;
}

]]>
			看了Linux内核代码linux/string.h中的一些字符串操作函数，有几个写的真是漂亮！


char * strstr(const char*, const char*)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * strstr - Find the first substring in a %NUL terminated string
 * @s1: The string to be searched
 * @s2: The string to search for
 */
char *strstr(const char *s1, const char *s2)
{
	int l1, l2;
 
	l2 = strlen(s2);
	if (!l2)
		return (char *)s1;
	l1 = strlen(s1);
	while (l1 >= l2) {
		l1--;
		if (!memcmp(s1, s2, l2))
			return (char *)s1;
		s1++;
	}
	return NULL;
}



void * memmove(void *, const void*)



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
28
29

/**
 * memmove - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * Unlike memcpy(), memmove() copes with overlapping areas.
 */
void *memmove(void *dest, const void *src, size_t count)
{
	char *tmp;
	const char *s;
 
	if (dest <= src) {
		tmp = dest;
		s = src;
		while (count--)
			*tmp++ = *s++;
	} 
	else {
		tmp = dest;
		tmp += count;
		s = src;
		s += count;
		while (count--)
			*--tmp = *--s;
	}
	return dest;
}



int strcmp(const char*, const char*)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * strncmp - Compare two length-limited strings
 * @cs: One string
 * @ct: Another string
 * @count: The maximum number of bytes to compare
 */
int strncmp(const char *cs, const char *ct, size_t count)
{
	signed char __res = 0;
 
	while (count) {
		if ((__res = *cs - *ct++) != 0 || !*cs++)
			break;
		count--;
	}
	return __res;
}


]]>
			http://www.dutor.net/index.php/2009/08/two-code/feed/
		1
		
		
		from const char** to char**
		http://www.dutor.net/index.php/2009/07/from-const-char/
		http://www.dutor.net/index.php/2009/07/from-const-char/#comments
		Wed, 08 Jul 2009 15:43:45 +0000
		dutor
				
		
		

		http://www.dutor.net/?p=880
		
char ** s; 
s是一个指针1，指向一个指针2, 指针2指向char

const char ** s; 
s是一个指针1，指向一个指针2，指针2指向char，char是常数

char * const * s; 
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向char

const char * const * s; 
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向char，char是常数

const char * const * const s; 
s是一个常量1，常量1是一个指针1，指针1指向一个常量2，常量2是个指针2，指针2指向char，char是常数
最后，感谢Felix的精彩解析！]]> 本文转载自：http://www.felix021.com/blog/read.php?1690
此文主要分析几种相似的二级字符指针定义方法的含义：

1
2
3
4
5

char ** a;
const char ** b;
char * const * c;
const char * const * d;
const char * const * const e;

看示例代码：

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#include <iostream>
#include <string>
 
using namespace std;
 
void test1(){
    char **s; //s是数组的指针;
    s = NULL;
    s = new char*[4];
    for (int i = 0; i < 4; ++i){
        s[i] = new char[10];
        strcpy(s[i], "test");
    }
    for (int i = 0; i < 4; ++i){
        printf("%s\n", s[i]);
    }
    for (int i = 0; i < 4; ++i){
        delete[] s[i];
    }
    delete[] s;
}
 
void test2(){
    const char **s; //s是指向字符串常量的指针
    s = NULL;
    char b[4][10] = {"a","b","c","d"};
    s = new const char*[4];
    for (int i = 0; i < 4; ++i){
        s[i] = b[i]; // OK
        //s[i][0] = 'd'; //这句要报错,因为s[i]指向的是字符串常量
                    //即使b[i]字符串本不是常量(编译期间添加的属性)
    }
    for (int i = 0; i < 4; ++i){
        printf("%s\n", s[i]);
    }
    delete[] s;
}
 
void test3(){
    char * const * s; //s指向常量数组，数组的每一个元素是字符指针常量。
                //数组的元素不可改，但数组元素指向的字符串可修改    
    s = NULL;// s不是常量
    char a[4][10] = {"aa", "bb", "cc", "dd"};
    char * const(b[4]) = {a[0], a[1], a[2], a[3]};
    s = b;
    for (int i = 0; i < 4; ++i){
        s[i][1] = 'd'; //OK
        //s[i] = NULL; //报错，因为s[i]是常量
        printf("%s\n", s[i]);
    }
}
 
void test4(){
    const char * const * s; //s指向一个常量指针数组
    //数组的每一个元素是字符指针常量，指向字符串常量(绕口令阿这是。。。)
    s = NULL;// s不是常量
    char a[4][10] = {"aa", "bb", "cc", "dd"};
    char * const(b[4]) = {a[0], a[1], a[2], a[3]};
    s = b;
    for (int i = 0; i < 4; ++i){
        //s[i][1] = 'd'; //报错，因为s[i][j]是常量
        //s[i] = NULL; //报错，因为s[i]是常量
        printf("%s\n", s[i]);
    }
}
 
void test5(){
    char a[4][10] = {"aa", "bb", "cc", "dd"};
    const char * const(b[4]) = {a[0], a[1], a[2], a[3]};
    const char * const * const s = b;
    //s是一个常量指针，指向一个常量指针数组
    //数组的每一个元素是字符指针常量，指向字符串常量(这才是绕口令！)
    //s = NULL; //Error, s是常量
    for (int i = 0; i < 4; ++i){
        //s[i][1] = 'd'; //报错，因为s[i][j]是常量
        //s[i] = NULL; //报错，因为s[i]是常量
        printf("%s\n", s[i]);
    }
}
 
int main(){
    test1();
	test2();
	test3();
	test4();
	test5();
    return 0;
}

总结：

char ** s;
s是一个指针1，指向一个指针2, 指针2指向char

const char ** s;
s是一个指针1，指向一个指针2，指针2指向char，char是常数

char * const * s;
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向char

const char * const * s;
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向char，char是常数

const char * const * const s;
s是一个常量1，常量1是一个指针1，指针1指向一个常量2，常量2是个指针2，指针2指向char，char是常数

最后，感谢Felix的精彩解析！

]]> http://www.dutor.net/index.php/2009/07/from-const-char/feed/ 3