【CAPL】字符串相关函数

strlen()字符串的长度

On key 'c'                
{
  char buffer[100] = "CANalyzer";                
  Write("strlen:%d",strlen(buffer));                
  Write("elCount:%d",elCount(buffer));                
}

• strlen 结果是实际的字符串长度
• elCount 结果是数组的定义长度

输出： strlen:9 elCount:100

strncat()将源字符串拼接到到目的字符串后面

注意“\0”也占用一个字节。

On key 'c'     
{
  int i ;     
  char s[10];     
  for(i=0;i<12;i++)     
  {
      strncpy(s, "12345", 10); // 初始化字符串数组 s = "12345"     
      strncat(s, "7890", i); //  根据指定长度参数拼接 字符串     
      write("i = %d  s = %s",i,s);     
  }
}

输出：

i = 0 s =
i = 1 s =
i = 2 s = 1
i = 3 s = 12
i = 4 s = 123
i = 5 s = 1234
i = 6 s = 12345
i = 7 s = 123457
i = 8 s = 1234578
i = 9 s = 12345789
i = 10 s = 123457890
i = 11 s = 123457890

从输出可以看出，指定的长度参数可以大于将输出的字符串长度正常显示，小于的话，从前往后截取。

strncmp() 字符串数组比较

On key 'c'     
{
    char s1[8] = "123456";     
    char s2[8] = "223456";     
    char s3[8] = "1234561";     
    char s4[8] = "12345";     
    char s5[8] = "123456";     
    write("s1:s2 = %d",strncmp(s1,s2,100));     
    write("s1:s3 = %d",strncmp(s1,s3,100));     
    write("s1:s4 = %d",strncmp(s1,s4,100));     
     write("s1:s5 = %d",strncmp(s1,s5,100));     
}

输出：
s1:s2 = -1
s1:s3 = -1
s1:s4 = 1
s1:s5 = 0

函数的机制是：逐个字符比较，遇见不同的字符，比较其ASCII值，然后返回值。

long strncmp_off(char s1[], long s1offset, char s2[], long s2offset, long len);

相比strncmp ，strncmp_off 多了个offset参数

On key 'c'     
{
    char s1[8] = "123456";     
    char s2[8] = "456";     
    write("s1:s2 = %d",strncmp_off(s1,3,s2,0,100));//s1[3:结束]和S2比较
}

输出：
s1:s2 = 0

strncpy() 把源字符串拷贝到目的字符串数组

拷贝长度由len参数决定，拷贝过程会覆盖目的字符串数组原来内容。

On key 'c'     
{
    char s1[20] = "123456";     
    char s2[8] = "789";     
    strncpy(s1,s2,elCount(s1));     
    write("s1 = %s",s1);     
    //清空字符串     
    strncpy(s1,"",elCount(s1));     
    write("s1 = %s",s1);     
}

输出:
s1 = 789
s1 =

void strncpy_off(char dest[], long destOffset, char src[], long max);

相当于 strncpy 和 strncat 的结合

On key 'c'     
{
  int i;     
char s1[20] = "123456";     
char s2[8] = "789";     
  for(i=0;i<strlen(s1) + 1;i++)  //strlen(s1) + 1 = 6

  {   
    strncpy_off(s1,i,s2,elCount(s1)); //根据offset 参数拷贝S2到S1
    write("s1 = %s",s1);     
    //初始化s1字符串数组     
    strncpy(s1,"123456",elCount(s1));     
  }
}

输出：
s1 = 789 //i=0
s1 = 1789 //i=1
s1 = 12789
s1 = 123789
s1 = 1234789
s1 = 12345789
s1 = 123456789 //i=5

strstr()搜索字符串

搜索到结果返回索引的位置。搜索到第一个匹配结束。

On key 'c'     
{
    long pos;     
    char s1[18] = "hello world";     
    char s2[11] = "world";     
    write("pos:%d",strstr(s1, s2));     
    write("pos:%d",strstr(s1, "l"));     
}

输出：
pos:6
pos:2

long strstr_off(char s1[], long offset, char s2[]);

规定被搜索的字符串数组位置。

On key 'c'     
{
    long pos,i;     
    char s1[18] = "hello world";     
    char s2[11] = "world";     
    for(i=0;i<strlen(s1)+1 ;i++)     
    {
      write("pos:%d",strstr_off(s1, i,"l"));     
    }
 }

输出：
pos:2
pos:2
pos:2
pos:3
pos:9
pos:9
pos:9
pos:9
pos:9
pos:9
pos:-1
pos:-1

str_replace()搜索并替代字符串


On key 'c'     
{
    long pos,i;     
    char s1[18] = "12121212";     
    char s2[11] = "world";     
    str_replace(s1, "1", "3");     
    write("s1:%s",s1);     
}

输出：
s1:32323232

long str_replace(char s[], long startoffset, char replacement[], long length); // form 2

用另一个字符串替代被搜索的字符串的一部分，注意期望的结果字符串数组大小不能大于被搜索的字符串数组

On key 'c'     
{
    long pos,i;     
    char s1[18] = "12345678";     
    str_replace(s1,4, "asdfg",strlen(s1));//form2 ，从索引4后面的字符串被"asdfg"替代
    write("s1:%s",s1);     
}

输出：
s1:1234asdfg

substr_cpy()拷贝源字符串的子字符串到目的字符串

On key 'c'     
{
long pos,i;     
char s1[18];     
char s2[18] = "12345678";     
for(i=0;i<5;i++)     
{
substr_cpy(s1, s2, i, 4, elcount(s1));      
write("s1:%s",s1);     
}

输出：
s1:1234
s1:2345
s1:3456
s1:4567
s1:5678

#void substr_cpy_off(char dest[], long destOffset, char src[], long srcStart, long len, long max)
拷贝源字符串的子字符串到目的字符串，相当于把源字符串的子字符串和目的子字符串 拼接在一起

[图片]

On key 'c'     
{
    long pos,i;     
    char s1[18] = "abcdefg";     
    char s2[18] = "12345678";     
    for(i=0;i<5;i++)     
    {
    substr_cpy_off(s1,i, s2, i, 4, elcount(s1));      
    write("s1:%s",s1);     
    strncpy(s1,"abcdefg",elCount(s1));     
}

输出：
s1:1234
s1:a2345
s1:ab3456
s1:abc4567
s1:abcd5678

swapWord()高低位切换

On key 'c'     
{
  
    write("Word:%x",swapWord(0x1234));     
    write("int:%x",swapInt(0x1234));     
    write("dword :%lx",swapDWord(0x12345678));     
    write("long :%lx",swapLong(0x12345678));     
    write("int64 :%I64x",swapInt64(0x1234567890876543LL));// 8个字节的整形，后面必须有"LL"后缀
    write("qword :%I64x",swapQWord(0x1234567890876543LL));
}

输出：
Word:3412
int:3412
dword :78563412
long :78563412
int64 :4365879078563412
qword :4365879078563412

toLower()将输入字符或者字符串转换成小写

On key 'c'     
{
    char s[20];     
    write("s :%c",toLower('A'));  // form1  ，转换单个字符     
    toLower(s, "aSdFgH", elcount(s)); // form2 ，转换字符串
    write("s :%s",s);     
}

输出：
s :a
s :asdfgh

toUpper()将输入字符或者字符串转换成大写

用法参考 toLower