C++中内存布局，内存地址：栈区>堆区>静态存储区

一、字符串常量和字符串变量

我们知道字符串常量是存储在文字常量区，也即C++中的静态存储区。

而字符串变量一般定义在栈区，当使用malloc时则定义在堆区。

  char* ss = "hello world";
  printf("%p\n", &ss); //字符串变量ss的存储地址（变量声明的地址）
  printf("%c: %p\n", ss[0],  &(ss[0]));//字符串变量ss中第一个字符h的存储地址
  printf("%c: %p\n", ss[1],  &(ss[1]));//字符串变量ss中第二个字符e的存储地址
  printf("%p\n", &"hello world");//字符串常量的首地址
  printf("%p\n", &("hello world"[0]));//字符串常量第一个字符h的存储地址
  printf("%p\n", &("hello world"[1]));//字符串常量第二个字符e的存储地址
  /*
  0x7fffecff31b8 栈区
  h: 0x401420    静态存储区
  e: 0x401421    静态存储区
  0x401420       静态存储区
  0x401420       静态存储区
  0x401421       静态存储区
  */

/*用malloc申请内存*/
  char* ss = (char*)malloc(128);
  memset(ss, 0, 128);
  strcpy(ss, "hello world");
  printf("%p\n", &ss); //字符串变量ss的存储地址（变量声明的地址）
  printf("%c: %p\n", ss[0],  &(ss[0]));//字符串变量ss中第一个字符h的存储地址
  printf("%c: %p\n", ss[1],  &(ss[1]));//字符串变量ss中第二个字符e的存储地址
  printf("%p\n", &"hello world");//字符串常量的首地址
  printf("%p\n", &("hello world"[0]));//字符串常量第一个字符h的存储地址
  printf("%p\n", &("hello world"[1]));//字符串常量第二个字符e的存储地址
  /*
  0x7ffc38cae008   栈区
  h: 0x628130      堆区
  e: 0x628131      堆区
  0x401470         静态存储区
  0x401470         静态存储区
  0x401471         静态存储区
  */

字符串变量存储在静态存储区;
	
在栈区声明一个字符串变量，char* ss = "hello world";这句代码会将栈区变量ss指向静态存储区的字符串，因此访问栈区ss变量时，是访问了静态存储区的"hello world"。
	
在栈区声明一个字符串变量，char* ss = (char*)malloc(128);这行代码在堆区申请了一块128字节的内存，并将栈区变量ss指向这块堆内存，strcpy(ss, "hello world");则将静态存储区的字符串拷贝至堆区。
其他需要注意的点：

我们在栈区char* ss时，只是在栈区声明了一个字符串变量，如果想使用strcpy拷贝字符串，则目的地址必须是申请的堆空间字符串变量地址，或者是栈空间的字符数组。

//  char* ss;
//  strcpy(ss, "hello world");//错误，不能讲常量字符串拷贝至一个字符串变量，因为该字符串变量没有申请空间存储

  char ss[128];
  memset(ss, 0, 128);
  strcpy(ss, "hello world");//正确，ss是栈空间的字符数组

 

二、string变量

string是C++定义的类，在其实现中，数据内容存储在堆空间中，在对象析构时将会释放其申请的堆内存，还要注意的是使用string的“+”运算符等时，拼接到一起的字符串其地址空间可能是不连续的。

  string tmpstr = "hello world";
  printf("tmpstr: %p\n", &tmpstr);//string变量tmpstr的存储位置
  printf("%c %p\n", tmpstr[0],  &(tmpstr[0]));//tmpstr变量中字符串第一个字符h存储的位置
  printf("%c %p\n", tmpstr[1],  &(tmpstr[1]));//tmpstr变量中字符串第二个字符e存储的位置
  printf("%c %p\n", tmpstr[10],  &(tmpstr[10]));//tmpstr变量中字符串第11个字符d存储的位置

  tmpstr += "123";//拼接一段字符串

  printf("%c %p\n", tmpstr[11],  &(tmpstr[11]));//拼接后的tmpstr第12个字符1存储的位置
  printf("%c %p\n", tmpstr[12],  &(tmpstr[12]));//拼接后的tmpstr第13个字符2存储的位置
  printf("%p\n", &"hello world");//"hello world"字符串首地址
  printf("%p\n", "hello world");

  /*
   tmpstr: 0x7ffe73dbd690 栈区
    h 0x9bf028            堆区
    e 0x9bf029
    d 0x9bf032
    1 0x9bf063
    2 0x9bf064
    0x400d20              静态存储区
    0x400d20
   */

 

1.错解
String str="123";
if(str.equals("123")){
}

2.正解
String str="123";
if("123".equals(str)){
}

3.分析

字符串常量斜前面，避免空指针异常。

空字符串

char s[]="";

即第dao一个字符是'\0'

 

空格字符

char s[]="   ";

只有空格组成的字符串字符串变量

 

char s[] = "abc";

s就是字符串变量

 

char *s = "abc";

s就是字符串常量，"abc"也是字符串常量。字符串里面的字符的值不能再改变了

 

主串和子串

char s[] = "abcdef";其中s全部的字符串"abcdef"，就是主串，其中连续的一部分，例如"abc","bcde","ef"等都可以叫子串。

 

串变量的名字与串变量的值

char s[] = "abcdef";

s是串的名字，"abcdef"是串的值。

关键词：字符串常量、字符串变量（引用）

为了了解字符串常量相加和字符串变量相加，首先看一个小例子：

public class SocketTest {
	public static void main(String[]args)throws Exception{
		String str1="abc";
		String str2="abc";
		String str3="eee";
		String str4="abceee";
		String str5=str1.concat(str3); //底层源码：用了new，创建了新对象
		System.out.println("abc"+"eee"=="abceee");//第一种情况：字符串常量相加，不含字符串变量
		System.out.println("abc"+"eee"==str4);
		System.out.println("abc"+str3=="abceee");//第二种情况：含字符串变量相加
		System.out.println(str1+str3=="abceee");
		System.out.println(str4==str5);
	}
}

//输出的结果：
true
true
false
false
false

分析：

1 字符串相加时如果含有字符串变量，则先在堆中开空间，再拼接，本质是new了StringBuilder对象进行append操作，拼接后调用toString()返回String对象。 

2 字符串相加时不含字符串变量，是先加，然后在常量池找，如果有就直接返回，否则，就在常量池中创建一个字符串常量，不会用到StringBuilder。