精华内容
下载资源
问答
  • 最近因实验需求,需要用代码有规律地自动生成变量名称并声明变量。通过翻阅资料,整理出来以下...第三个是:将字符串转换成变量名称数字转换为字符的方法在Octave中有num2str函数可供调用,例如数字2转换为字

    最近因实验需求,需要用代码有规律地自动生成变量名称并声明变量。通过翻阅资料,整理出来以下可行方案。

    首先是有规律地生成变量名称,我们可能需要生成变量名为list1,list2,list3……这样的名称,名称中的字符串“list”是固定不变的,后面跟的数字是变化的。我们想要用代码实现这一串变量名称的自动生成,需要解决的问题有三个。第一个是:将数字转换为字符。第二个是:拼接两个字符串。第三个是:将字符串转换成变量名称。

    将数字转换为字符的方法在Octave中有num2str函数可供调用,例如将数字2转换为字符,可以用以下语句:

    num2str(2)

     更多实例:

    拼接两个字符串,可以用以下几种方法

    1.通过 c=[a1,b1]格式拼接,实例如下

    >> a = 'sdf'
    a = sdf
    >> b = 'dfgfg'
    b = dfgfg
    >> c = [a,b]
    c = sdfdfgfg
    >> d = ['dfd','fdf']
    d = dfdfdf

    2.通过调用函数 strcat来实现

    >> a = 'sdf'
    a = sdf
    >> b = 'dfgfg'
    b = dfgfg
    >> d=strcat(a,b)
    d = sdfdfgfg

    将字符串转换为变量名称

    使用函数eval来实现

    >> str = ['dsfd',num2str(4)]
    str = dsfd4
    >> eval( [str, '= zeros(1,6)'])
    dsfd4 =
    
       0   0   0   0   0   0

    好啦,到这里所有的问题都解决了,我用代码循环生成了我需要的变量。list2,list3,list4……list10。

    for c = 0.2:0.1:1
       str = ['list',num2str(c*10)]
       eval( [str, '= zeros(1,20)'])
    endfor
    
    str = list2
    list2 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list3
    list3 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list4
    list4 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list5
    list5 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list6
    list6 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list7
    list7 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list8
    list8 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list9
    list9 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    
    str = list10
    list10 =
    
       0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

     

    展开全文
  • 字符串

    千次阅读 2018-07-18 15:57:17
    本篇介绍一种新的变量类型:字符串字符串与字符数组不同的地方就在于:字符数组的大小在声明时就已经定了下来;而字符串的大小是可以改变的,当你往字符串里面添加元素时,字符串的大小也会相应地改变。下面...

    本篇将介绍一种新的变量类型:字符串

    字符串与字符数组不同的地方就在于:字符数组的大小在声明时就已经定了下来;而字符串的大小是可以改变的,当你往字符串里面添加元素时,字符串的大小也会相应地改变。下面介绍对于字符串的操作(转载自YCOJ):


    s.size(); // 得到字符串长度

    s.find(); // 查找字符或子串所在位置,若存在子串则返回子串开头字符下标,否则返回-1

        s.find('a');
        s.find("hello");
        s.find("hello", 2);//从字符串s下标2往后面查找
    
    

    s.replace(); // 字符串s某个部分替换成另一个字符串

        s.replace(0, 5, "hello");//字符串s从下标0开始,长度为5的部分替换成"hello"
    
    

    s.substr(); // 取字符串某个部分(子串)

        s.substr(2);    //取字符串s从下标2开始到结束的部分
        s.substr(2,5);  //取字符串s从下标2开始长度为5的部分
    
    

    △ 字符串拼接

        s = s + 'a';
        s = s + "hello";
        s += "hello";
        s = "hello" + "world";//注意,这种写法是错的(想一想为什么?)
    
    

    getline(); // 读入一行,用法:

        getline(cin, s);
    
    

    △ 字典序 联系英语词典单词的排序方式,如果你能够轻松的对这几个字符串按字典序排序,那么可以断定你已经理解了:

        abs
        ab
        abc
        abcde
    
    

    △ 字典序比较:string类型的字符串也可用下面比较符

        >
        <
        ==
        >=
        <=
        !=

    下面是一些字符串的习题:


    字符串中A的数量

    Description

    输入一个字符串,统计其中字符 A 的数量并且输出。

    Input

    输入共有一行,为一个不带空格的字符串(其中字符数不超过 100)。

    Output

    输出一行,包含一个整数, 为输入字符串中的 A 的数量。

    这题只需要用size()函数得到字符串的长度,然后用for循环一个字符一个字符地访问看是不是'A’就可以了:

    #include<iostream>
    #include<cstring>//有关字符串的操作都需要加上cstring的头文件
    using namespace std;
    
    int main(){
    	string s;
    	cin >> s;
    	
    	int cnt = 0;//记录'A'出现的次数
    	for(int i = 0; i < s.size(); i++){
    		if(s[i] == 'A'){
    			cnt++;
    		}
    	}
    	
    	cout << cnt;
    	return 0;
    }

    *这里需要注意的是,字符串的下标是从0开始,到字符串长度减一结束的。

    当然了,使用find()函数也是可以做的,但是对下标的控制需要熟练:

    #include<iostream>
    #include<cstring>
    using namespace std;
    
    int main(){
    	string s;
    	cin >> s;
    	
    	int cnt = 0;
    	int d = -1;//存储下标的值
    	do{
    		d = s.find('A', d + 1);
    		if(d != -1) cnt++;
    	}while(d != -1);
    	
    	cout << cnt;
    	return 0;
    }

    下一个字母

    Description

    从键盘输入一个长度大于 10 的字符串,现要求:将字符串中的所有大小写字母都改写成该字母的下一个字母;特殊的,小写字母 z 改写成字母 a;大写字母 Z 改写成 A,其他字符依照原有顺序不变。

    Input

    输入只有一行,包含 1 个任意的不带有空格的字符串(其长度在 10 到 1000 之间)。

    Output

    输出只有一行,即为满足条件的字符串。

    对于字符,是可以当做整数来进行运算的(具体参照ASCII码)。这题需要对'Z'和‘z’进行特殊判断一下。代码如下:

    #include<iostream>
    #include<cstring>
    using namespace std;
    
    int main(){
      string str;
      cin >> str;
      
      int len = str.size();
      for(int i = 0; i < len; i++){
        if((str[i] >= 'A' && str[i] <= 'Z') || (str[i] >= 'a' && str[i] <= 'z') ){
          str[i]++;
          if(str[i] > 'Z' && str[i] < 'a') str[i] = 'A';
          else if(str[i] > 'z') str[i] = 'a';
    	}
      }
      
      cout << str << endl;
      return 0;
    }

    选小寿星

    Description

    五年级一班有一个传统,全班一起庆祝当月过生日的同学。有 m 名学生都是 1 月份过生日,班主任决定挑一名学生作为寿星代表切蛋糕。班主任将过生日的 m 名学生随机围成一个圈,从 1 到 m 进行编号。随机挑一个数字 n(1≤n≤9),从第一个同学开始连续报数,报数到 n 的同学就出局,然后从下一位 同学重新开始报数,一直到剩下最后一名同学。由于女生少,班主任决定每个女生有 2 次机会,也就是说,每名女生第 2 次数到 n 时才出局。

    例如,m=3,其中有 1 名女生,编号顺序为 1,2,3,分别是男,女,男,n=2。第一轮报数,报到的是 2 号女生,暂不出局(注:女生有 2 次机会)。第二轮报数,3 号男生报 1,1 号男生报 2 出局。第三轮报数,2 号女生报 1,3 号男生报 2 出局,最后留下 2 号女生。

    Input

    输入第一行输入数字为 m,表示有 m 个人,m<20。

    第二行是 m 个整数,1 代表男生,0 代表女生。

    第三行是 n,表示 n 是出局数字。(注意:女生有 2 次机会)

    Output

    输出留下学生的序号,中间用空格隔开。

    这题就比较经典了。这题需要将出局的学生进行标记,直到只有一个人未被标记时,游戏结束。

    #include<iostream>
    using namespace std;
    
    const int maxn = 10000 + 5;
    bool sex[maxn];//记录学生的性别,0为女生、1为男生
    
    int main(){
      int m; cin >> m;
      for (int i = 1 ; i <= m ; i++) cin >> sex[i];
      int n; cin >> n;
      
      int stu[maxn];
      for (int i = 1 ; i <= m ; i++) {
      	if (sex[i] == 0) stu[i] = 2 ;//女生两次机会
      	else stu[i] = 1;//男生一次机会
      }
      
      int t = 0 ;
      int chance = 0 ;//记录总共的机会数
      for(int i = 1 ; i <= m ; i++) chance += stu[i] ;
      
      for (int i = 1 ; ; i++) {
      	if(chance == 1) break ;//当总机会数只剩下1时,不论剩下男生还是女生,游戏都将结束
        if(i == m+1) i = 1 ;//将队伍的首位连接起来
      	if(stu[i] == 0) continue ;//如果轮到的人已经出局,不进行下面的操作,进行下一次循环
      	t++ ;//报数
      	if(t == n){
      	  t = 0 ;
      	  stu[i]-- ;
      	  chance-- ;
    	}//报到n的人减少一次机会,总机会数也减一,报出的数归零。
      }
      
      int temp = 0 ;
      for(int i = 1 ; i <= m ; i++){
      	if(stu[i] != 0) cout << i ;//寻找未出局的人
      }
      return 0 ;
    }

    这里是考察对数据的操控。


    规范化名字

    Description

    一个 名单里面有大型机械的很多零部件名,但是由于制作这个名单的人习惯不太好,零部件的名称的大小写很混乱。有的是大写字母开头,有些是小写字母开头,零部件名称中间的字符也是大小写混乱。

    请你设计程序,将名单上零部件的名称都变为开头字母大写,后面字母全小写的形式。

    Input

    输入第一行只有一个正整数 N,表示名单上的零部件(1≤N≤100)。

    之后的 N 行: 为 N 个零部件的名称。

    Output

    输出为 N 行,为所有 N 个零部件的名称, 首字母为大写,后面 的字母为小写。

    这里要用到c++中的两个函数:toupper(),tolower(),它们的作用分别是将字母转大写、转小写。代码如下:

    #include<iostream>
    #include<cstring>
    using namespace std;
    
    int main(){
      int n; cin >> n;
      string name[n + 1];
      for(int i = 1; i <= n; i++) cin >> name[i];
      
      int len[n + 1];
      for(int i = 1; i <= n; i++){
      	len[i] = name[i].size();
      }
      
      for(int i = 1; i <= n; i++){
      	for(int j = 0; j < len[i]; j++){
      	  if(j == 0) name[i][j] = toupper(name[i][j]);
      	  else name[i][j] = tolower(name[i][j]);
    	}
      }
      
      for(int i = 1; i <= n; i++){
      	cout << name[i] << endl;
      }
      return 0;
    }

    禁止吸烟

    Description

    小信的学校设计了很多的标语,但是中间很多地方都把 No_smoking 写成了 Ban_smoking。请你找到这些错误并将他们替换成正确的结果。

    Input

    输入第一行为 N 表示总共的标语数量。

    之后的 N 行每行是一个待处理的标语。每个标语中不带有任何的空格。

    Output

    输出为 N 行, 为经过处理后的所有的标语。输出顺序与输入时保持 一致。

    这题只要灵活使用find()、replace()就可以了。代码如下:

    #include<iostream>
    #include<cstring>
    using namespace std;
    
    const int maxn = 10000+5;
    const string wstr = "Ban_smoking", re = "No_smoking";
    const int lenws = 11;//"Ban_smoking"的长度
    
    int main(){
      int n;
      cin >> n;
      
      string sign[maxn];
      for(int i = 1; i <= n; i++) cin >> sign[i];
      
      for(int i = 1; i <= n; i++){
      	int beg;
      	beg = sign[i].find(wstr);
      	while(beg != -1){
      	  sign[i].replace(beg, lenws, re);
      	  beg = sign[i].find(wstr);
    	}
    	cout << sign[i] << endl;
      }
      return 0;
    }

     

    展开全文
  • C++ 字符串与字符数组 详解

    万次阅读 多人点赞 2018-03-03 19:28:22
    在C++中,有两种类型的字符串表示形式: C-风格字符串 C++引入的string类 C-风格字符串 C 风格的字符串起源于 C 语言,并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。...

    在C++中,有两种类型的字符串表示形式:

    • C-风格字符串
    • C++引入的string类

    C-风格字符串

    C 风格的字符串起源于 C 语言,并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。因此,一个以 null 结尾的字符串,包含了组成字符串的字符。
    下面的声明和初始化创建了一个 “Hello” 字符串。由于在数组的末尾存储了空字符,所以字符数组的大小比单词 “Hello” 的字符数多一个。

    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

    其实,您不需要把 null 字符放在字符串常量的末尾。C++ 编译器会在初始化数组时,自动把 ‘\0’ 放在字符串的末尾。所以也可以利用下面的形式进行初始化

    char greeting[] = "Hello";

    以下是 C/C++ 中定义的字符串的内存表示:
    这里写图片描述
    C++ 中有大量的函数用来操作以 null 结尾的字符串:

    序号函数功能
    1strcpy(s1,s2)复制字符串 s2 到字符串 s1
    2strcat(s1,s2)连接字符串 s2 到字符串 s1 的末尾
    3strlen(s1)返回字符串 s1 的长度
    4strcmp(s1,s2)返回s1与s2的比较结果
    5strchr(s1,ch)返回一个指针,指向字符串s1中字符ch的第一次出现的位置
    6strstr(s1,s2)返回一个指针,指向字符串s1中s2的第一次出现的位置

    C++ 中的 String 类

    C++ 标准库提供了 string 类类型,支持上述所有的操作,另外还增加了其他更多的功能。比如:

    • append() – 在字符串的末尾添加字符
    • find() – 在字符串中查找字符串
    • insert() – 插入字符
    • length() – 返回字符串的长度
    • replace() – 替换字符串
    • substr() – 返回某个子字符串

    4种字符串类型

    C++中的字符串一般有以下四种类型,

    • string

    • char*

    • const char*
    • char[]

    下面分别做简单介绍,并说明其中的一些区别

    string

    string是一个C++类库中的一个类,它位于名称空间std中,因此必须使用using编译指令或者std::string来引用它。它包含了对字符串的各种常用操作,它较char*的优势是内容可以动态拓展,以及对字符串操作的方便快捷,用+号进行字符串的连接是最常用的操作

    char*

    char* 是指向字符串的指针(其实严格来说,它是指向字符串的首个字母),你可以让它指向一串常量字符串。

    const char*

    该声明指出,指针指向的是一个const char类型,即不能通过当前的指针对字符串的内容作出修改

    注意这里有两个概念:

    • char * const [指向字符的静态指针]
    • const char * [指向静态字符的指针]

    前者const修饰的是指针,代表不能改变指针
    后者const修饰的是char,代表字符不能改变,但是指针可以变,也就是说该指针可以指针其他的const char。

    char[]

    与char*与许多相同点,代表字符数组,可以对应一个字符串,如

    char * a="string1";
    char b[]="string2";

    这里a是一个指向char变量的指针,b则是一个char数组(字符数组)
    也就是说:

    二者的不同点

    一,char*是变量,值可以改变, char[]是常量,值不能改变!
    a是一个char型指针变量,其值(指向)可以改变;
    b是一个char型数组的名字,也是该数组首元素的地址,是常量,其值不可以改变

    二,char[]对应的内存区域总是可写,char*指向的区域有时可写,有时只读
    比如:

    char * a="string1";
    char b[]="string2";
    gets(a); //试图将读入的字符串保存到a指向的区域,运行崩溃! 
    gets(b) //OK

    解释: a指向的是一个字符串常量,即指向的内存区域只读;
    b始终指向他所代表的数组在内存中的位置,始终可写!

    注意,若改成这样gets(a)就合法了:

    char * a="string1";
    char b[]="string2";
    a=b; //a,b指向同一个区域
    gets(a) //OK
    printf("%s",b) //会出现gets(a)时输入的结果

    解释: a的值变成了是字符数组首地址,即&b[0],该地址指向的区域是char *或者说 char[8],习惯上称该类型为字符数组,其实也可以称之为“字符串变量”,区域可读可写。

    总结:char *本身是一个字符指针变量,但是它既可以指向字符串常量,又可以指向字符串变量,指向的类型决定了对应的字符串能不能改变!

    三,char * 和char[]的初始化操作有着根本区别:
    测试代码:

    char *a="Hello World"; 
    char b[]="Hello World"; 
    printf("%s, %d\n","Hello World", "Hello World"); 
    printf("%s, %d %d\n", a, a,  &a);                           
    printf("%s, %d %d\n", b,     b,  &b);

    结果:

    Hello World,13457308
    Hello World,13457308    2030316
    Hello World,2030316 2030316

    结果可见:尽管都对应了相同的字符串,但”Hellow World”的地址 和 a对应的地址相同,与b指向的地址有较大差异;&a 、&b都是在同一内存区域,且&b==b
    根据c内存区域划分知识,我们知道,局部变量都创建在栈区,而常量都创建在文字常量区,显然,a、b都是栈区的变量,但是a指向了常量(字符串常量),b则指向了变量(字符数组),指向了自己(&b==b==&b[0])。
    说明以下问题:
    char * a=”string1”;是实现了3个操作:

    1. 声明一个char*变量(也就是声明了一个指向char的指针变量);
    2. 在内存中的文字常量区中开辟了一个空间存储字符串常量”string1”
    3. 返回这个区域的地址,作为值,赋给这个字符指针变量a

    最终的结果:指针变量a指向了这一个字符串常量“string1”
    (注意,如果这时候我们再执行:char * c=”string1”;则,c==a,实际上,只会执行上述步骤的1和3,因为这个常量已经在内存中创建)

    char b[]=”string2”;则是实现了2个操作:

    1. 声明一个char 的数组,
    2. 为该数组“赋值”,即将”string2”的每一个字符分别赋值给数组的每一个元素

    最终的结果:“数组的值”(注意不是b的值)等于”string2”,而不是b指向一个字符串常量

    实际上, char * a=”string1”; 的写法是不规范的!
    因为a指向了即字符常量,一旦strcpy(a,”string2”)就糟糕了,试图向只读的内存区域写入,程序会崩溃的!尽管VS下的编译器不会警告,但如果你使用了语法严谨的Linux下的C编译器GCC,或者在windows下使用MinGW编译器就会得到警告。
    所以,我们还是应当按照”类型相同赋值”的原则来写代码:

    const char * a="string1";

    保证意外赋值语句不会通过编译

    另外,关于char*和char[]在函数参数中还有一个特殊之处,运行下面的代码

    void fun1 ( char *p1,  char p2[] ) {
     printf("%s %d %d\n",p1,p1,&p1);
     printf("%s %d %d\n",p2,p2,&p2);
    p2="asdf"; //通过! 说明p2不是常量! 
    printf("%s %d %d\n",p2,p2,&p2);
    }
    void main(){
    char a[]="Hello";
    fun1(a,a);
    }

    运行结果:

    Hello 3471628 3471332
    Hello 3471628 3471336
    asdf 10704764 3471336

    结果出乎意料!上面结果表明p2这时候根本就是一个指针变量!
    结论是:作为函数的形式参数,两种写法完全等效的!都是指针变量!

    const char*与char[]的区别:
    const char * a=”string1”
    char b[]=”string2”;
    二者的区别在于:

    1. a是const char 类型, b是char const类型
      ( 或者理解为 (const char)xx 和 char (const xx) )

    2. a是一个指针变量,a的值(指向)是可以改变的,但a只能指向(字符串)常量,指向的区域的内容不可改变;

    3. b是一个指针常量,b的值(指向)不能变;但b指向的目标(数组b在内存中的区域)的内容是可变的

    4. 作为函数的声明的参数的时候,char []是被当做char *来处理的!两种形参声明写法完全等效!

    字符串类型之间的转换: string、const char*、 char* 、char[]相互转换

    一、转换表格

    源格式->目标格式stringchar*const char*char[]
    stringNULL直接赋值直接赋值直接赋值
    char*strcpyNULLconst_castchar*=char
    const char*c_str()直接赋值NULLconst char*=char;
    char[]copy()strncpy_s()strncpy_s()NULL

    二、总结方法:

    1. 变成string,直接赋值。
    2. char[]变成别的,直接赋值。
    3. char*变constchar*容易,const char*变char*麻烦。<const_cast><char*>(constchar*);
    4. string变char*要通过const char*中转。
    5. 变成char[]。string逐个赋值,char* const char* strncpy_s()。

    三,代码示例

    1、string转为其他类型

    ①、string转const char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        std::string str = "HelloWorld!";     //初始化string类型,并具体赋值
        const char* constc = nullptr;         //初始化const char*类型,并赋值为空
        constc= str.c_str();                 //string类型转const char*类型
        printf_s("%s\n", str.c_str());        //打印string类型数据 .c_str()
        printf_s("%s\n", constc);             //打印const char*类型数据
        return 0;
    }

    ②、string转char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        std::string str = "HelloWorld!";     //初始化string类型,并具体赋值
        char* c = nullptr;                    //初始化char*类型,并赋值为空
        const char* constc = nullptr;         //初始化const char*类型,并赋值为空
        constc= str.c_str();                 //string类型转const char*类型
        c= const_cast<char*>(constc);        //const char*类型转char*类型
        printf_s("%s\n", str.c_str());        //打印string类型数据 .c_str()
        printf_s("%s\n",c);                  //打印char*类型数据
        return 0;
    
    }

    ③、string转char[]

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        std::string str = "HelloWorld!";      //初始化string类型,并具体赋值
        char arrc[20] = {0};                   //初始化char[]类型,并赋值为空
        for (int i = 0; i < str.length(); i++) //string类型转char[]类型
        {
            arrc[i]=str[i];
        }
        printf_s("%s\n", str.c_str());         //打印string类型数据 .c_str()
        printf_s("%s\n", arrc);                //打印char[]类型数据
        return 0;
    }

    2、const char*转为其他类型

    ①const char*转string

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        const char* constc = "Hello World!";     //初始化const char* 类型,并具体赋值
        std::string str;                        //初始化string类型
        str= constc;                            //const char*类型转string类型
        printf_s("%s\n", constc);                //打印const char* 类型数据
        printf_s("%s\n", str.c_str());           //打印string类型数据
        return 0;
    }

    ②const char*转char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        const char* constc = "Hello World!";     //初始化const char* 类型,并具体赋值
        char* c = nullptr;                       //初始化char*类型
        c= const_cast<char*>(constc);           //const char*类型转char*类型
        printf_s("%s\n", constc);                //打印const char* 类型数据
        printf_s("%s\n", c);                     //打印char*类型数据
        return 0;
    }

    ③const char*转char[]

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        const char* constc = "Hello World!";     //初始化const char* 类型,并具体赋值
        char arrc[20] = { 0 };                   //初始化char[]类型,并赋值为空
        strncpy_s(arrc,constc,20);              //const char*类型转char[]类型
        printf_s("%s\n", constc);                //打印const char* 类型数据
        printf_s("%s\n", arrc);                  //打印char[]类型数据
        return 0;
    }

    3、char*转为其他类型

    ①char*转string

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char* c = "HelloWorld!";           //初始化char* 类型,并具体赋值
        std::string str;                   //初始化string类型
        str= c;                            //char*类型转string类型
        printf_s("%s\n", c);                //打印char* 类型数据
        printf_s("%s\n", str.c_str());      //打印string类型数据
        return 0;
    }

    ②char*转const char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char* c = "HelloWorld!";         //初始化char* 类型,并具体赋值
        const char* constc = nullptr;     //初始化const char* 类型,并具体赋值
        constc= c;                       //char*类型转const char* 类型
        printf_s("%s\n", c);              //打印char* 类型数据
        printf_s("%s\n", constc);         //打印const char* 类型数据
        return 0;
    }

    ③char*转char[]

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char* c = "HelloWorld!";         //初始化char* 类型,并具体赋值
        char arrc[20] = { 0 };           //初始化char[] 类型,并具体赋值
        strncpy_s(arrc,c,20);             //char*类型转char[] 类型
        printf_s("%s\n", c);              //打印char* 类型数据
        printf_s("%s\n", arrc);           //打印char[]类型数据
        return 0;
    }

    4、char[]转为其他类型

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char arrc[20] = "HelloWorld!";//初始化char[] 类型并具体赋值
        std::string str;                 //初始化string
        const char* constc = nullptr;   //初始化const char*
        char*c = nullptr;                //初始化char*
        str= arrc;                     //char[]类型转string类型
        constc= arrc;             //char[]类型转const char* 类型
        c= arrc;                        //char[]类型转char*类型
        printf_s("%s\n", arrc);         //打印char[]类型数据
        printf_s("%s\n", str.c_str());  //打印string类型数据
        printf_s("%s\n", constc);       //打印const char* 类型数据
        printf_s("%s\n", c);            //打印char*类型数据
        return 0;
    }
    展开全文
  • 1、字符与字符串   方法名称 类型 功能 public String(char[] value) 构造 字符数组变为String类对象 public String(char[] v...

    1、字符与字符串

             

    方法名称                                           类型                     功能
    
    public String(char[] value)                       构造             将字符数组变为String类对象
    public String(char[] value,int offset,int count)  构造             将部分字符串数组变成String
    public charcharAt(int index)                      普通             返回指定索引对应的字符  
    public char[]toCharArray()                        普通             将字符串变为字符数组 
            

    字符串转大小写,通过大小字母相差32,进行加减转换,再将数字转为对应字母

    2、字节与字符串

    使用字节一般用于数据传输和进行字符编码转换;将字符串变为字节数组的操作,目的就是为了传输以及编码转换

    方法名称                                      类型                    功能
    
    public String(byte[] bytes)                  构造                 将全部字节数组变为字符串
    public String(char[] value,int offset,int length)  构造           将部分字节数组变成String
    public getBytes()                            普通                 将字符串变成字节数组
    public byte[] getBytes(String charsetName) throws UnsupportedEncodingException  普通           进行编码转换

    3、字符串比较

     

    方法名称                           类型                            功能
    public boolean equals(String anObject)      普通                          判断相等,区分大小写
    
    public boolean equalsIgnoreCase(String anotherSring)  普通                判断相等,不区分大小写
    public int compareTo(String anotherString)     普通             判断字符串的大小(按照字符编码比较),返回值,=0字符串内容相等  >0大于的结果,<0小于的结果
    
    

    4、字符串查找

    public boolean contains(String s) 普通   返回boolean 判断字符是否存在
    public int indexOf(String str)   普通    在字符串中依次查询出字符第一出现的位置,没有返回-1
    public int indexOf(String str,int fromIndex) 普通  由指定位置从前象后查找指定字符串的位置,找不到返回-1
    public int lastIndexOf(String str) 普通  由后向前查找指定字符串的位置,找不到返回-1
    public int indexOf(String str,int fromIndex) 普通  由后指定位置从前象后查找指定字符串的位置,找不到返回-1
    public boolean startsWidth(String prefix)  普通      判断是否以指定的字符串开头
    public boolean startsWidth(String prefix,int toffset)  普通  从指定位置开始判断是否以指定的字符串开头
    public boolean endsWidth(String stuffix)  普通      判断是否以指定的字符串结尾

    5、字符串替换

    public String replaceAll(String regex,String replacement) 普通 用心的内容替换旧的内容 全部替换
    public String replaceFirst(String rregex,String replacement) 普通 替换首个指定字符

    6、字符串截取

    puiblic String substring (int beginIndex)  普通  从指定位置开始截取到末尾
    public String substring(int beginIndex, int endIndex) 普通 从指定开始位置截取到指定结束位置 
    

    7、字符串拆分

    public String[] split(String regex) 普通  按照指定的字符串进行拆分
    punlic String[] split(String regex, int limit) 按照指定的字符串进行部分拆分,最后的数组长度就是由limit提供

    8、其他

    public String concat(String str)  普通  字符串连接
    public String toLowerCase()   普通  转小写
    public String toUpperCae()  普通 转大写
    public String trim() 普通 消除空格
    public int length() 普通  取得字符串length
    public String intern() 普通 数据入池
    public boolean isEmpty() 普通 判断字符串是否为空(空字符串为 "",null为对象)

     

    展开全文
  • 用字符串的方式读取变量名, locals() 函数会以字典类型返回当前位置的全部局部...字符串变成同名变量名 输入 import inspect, re def varname(p): for line in inspect.getframeinfo(inspect.currentframe().f_b...
  • 详解 Python 字符串(一):字符串基础

    千次阅读 多人点赞 2021-01-16 20:59:45
    文章目录1.2. 在 Python 中,字符串就是一串字符的组合,它是不可变的、有限字符序列,包括可见字符、不可见字符(如空格符等)和转义字符。Python 通过 str 类型...本文详细介绍操作字符串的一般方法。 1. 2. ...
  • 数组变成字符串输出

    千次阅读 2020-07-13 18:38:14
    * 需求:把数组中的数据按照指定格式拼接成一个字符串 * 举例: * int[] arr = {1,2,3}; * 输出结果: * "[1,2,3]" *分析: * A;定义一个字符串对象,内容为空 * B; 先把字符串拼接一个"[" * C:遍历...
  • 给定一个字符串其中所有的小写字母转换成大写字母。 输入 输入一行,包含一个字符串(长度不超过100,可能包含空格)。 输出 输出转换后的字符串。 输入样例1 helloworld123Ha 输出样例1 HELLOWORLD123HA 来源 ...
  • es6字符串转模板字符串 本文是Microsoft的Web开发系列的一部分。 感谢您支持使SitePoint成为可能的合作伙伴。 ES6是JavaScript的未来,而且已经存在。 它是一个最终的规范,它带来了语言必须具备的许多功能,以与...
  • 本文介绍了三种在springMVC的情况下,将字符串转化为日期格式的方法
  • 主要介绍了java实现将字符串中首字母转换成大写,其它全部转换成小写的方法,涉及java字符串遍历、转换、拼接等相关操作技巧,需要的朋友可以参考下
  • C++字符串基础

    2018-12-19 20:53:03
    字符串 字符串是存储在内存的连续字节中的一...存储在连续字节中的字符意味着可以将字符串保存在char数组中,其中每个字符都位于自己的数组元素中。C-风格字符串(c-string)具有一种特殊的性质:以空字符(null)结...
  • RT,C++的,Qt中的。现在是让用户输入变量名称。客户在TextEdit控件中输入名称,和类型,生成相应名称的变量。例如,用户选择int类型,在... 因为用户输入的是字符串,后台获得的也是字符串“abc”,如何转换成变量名?
  • eval用途1:字符串转变为变量名称

    千次阅读 2014-02-23 17:03:20
    在程序中,有时变量名字在写程序时确定不了,或者有很多变量名字类似(例如"var1, var2, var3,..,")...那么如何将字符串变为变量名称呢? 这个时候就可以用eval函数啦! b = eval('a'); //变量a的值赋给
  • 将字符串转化为整型

    千次阅读 2014-07-05 16:02:53
    @函数名称: atol  函数原型: long atol(char ... 函数功能: 将字符串转换成一个长整数  函数返回: 转换后的数值  参数说明: str-待转换为长整型的字符串  所属文件:   #include   #include   
  • Oracle之字符串函数

    2019-01-26 21:27:11
    我们传入的字符串变为大写 字符串 LOWER(列///字符串) 我们传入的字符串变为小写字母显示 字符串 INITCAP(列///字符串) 开头首字母大写,其他小写 数字 LENGTH(列///字符串) 取得制定字符...
  • js如何字符串作为函数名调用函数 一、总结 一句话总结:用eval来实现。eval可以执行参数字符串。 二、js将字符串作为函数名调用函数 比如我现在有一个字符串str = "func_abc",func_abc是一个函数名,我现在...
  • BAT批处理中的字符串处理详解(字符串截取) BAT批处理中的字符串处理详解(字符串截取 批处理有着具有非常强大的字符串处理能力,其功能绝不低于C语言里面的字符串函数集。批处理中可实现的字符串处理功能有:...
  • C# 如何利用反射,将字符串转化为类名并调用类中方法
  • 将字符串写入txt并压缩到zip包

    千次阅读 2018-03-19 15:00:49
    * 将字符串写入文本文件并写入压缩包 * @param response response对象 * @param fileName 下载的文件名称 (下载后需要给文件的名称) * @param response 字符串 * @throws Exception */ private void ...
  • 一、需求描述输入一个字符串,编写程序字符串中的各个单词反序拼装并输出。例如,如果输入的字符串是“Hello, how do you do”,那么输出的字符串为“do you do how Hello,”。注意保留各个单词之间的空格及相应...
  • 主要介绍了python函数中将变量名转换成字符串实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 折腾Redis之字符串

    千次阅读 多人点赞 2020-06-27 00:00:48
          字符串是Redis五种基本数据类型中的基础...Redis中所有的数据结构都是以唯一的key字符串作为名称,根据此key获取value,差异仅在于value的数据结构不同。string使用非常广泛,最常
  • NSString *strClass = NSStringFromClass([self class]); // 把当前类封装成字符串 UIViewController *viewController = NSClassFromString(strClass); // 把字符串 转换成 class
  • 字符串问题

    千次阅读 2017-03-13 10:53:38
    第1章 字符串 编程之法:面试和算法心得 与字符串相关的问题在各大互联网公司的笔试和面试中出现的频率极高。例如,网上广为流传的一道单词翻转题:输入“I am a student.”,要求输出“student. a am I...
  • C++字符串数组

    万次阅读 多人点赞 2019-05-30 22:43:54
    C++提供了一种新的数据类型——字符串类型(string类型),在使用方法上,它和char、int类型一样,可以用来定义变量,这就是字符串变量——用一个名字代表一个字符序列。 实际上,string并不是C++语言本身具有的基本类型,它...
  • Python 如何将字符串常量转为变量?

    千次阅读 2019-04-18 20:25:10
    1、如何动态生成变量名? M同学的问题如下: 打扰一下大家,请教个问题...简单理解,这个问题的意思是,将字符串内容作为其它对象的变量名。 list 中的元素是字符串,此处的 ‘A’-‘D’ 是常量,而在要求的结果...
  • #define enumtoCharArr(val) #val #define enumtoStr(val) Setstr(#val) CString Setstr(const char * val) { string str = val; return str.c_str(); } enum EGrabStrategy ... G...
  • python中的常用字符串

    2020-04-23 23:18:56
    字符串的定义方式2. 字符串的特性1.索引2.切片3.重复4.连接5.成员操作符号(检索)6.字符串的判定7.判断文件名称的结尾8.判断文件名称的开头练习 1. 字符串的定义方式 字符串或串(String)是由数字、字母、下划线...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 227,290
精华内容 90,916
关键字:

如何将字符串变成名称