C 언어 char s[]와 char*s 의 차이

C 언어 지침 은 배열 대신 사용 할 수 있다.
1.배열 본질
배열 은 여러 요소 의 집합 으로 메모리 에 주소 가 연속 되 는 단원 에 분포 되 어 있 기 때문에 아래 표 시 를 통 해 배열 의 서로 다른 배열 에 접근 할 수 있 습 니 다.
예 를 들 면:
다음 에 보 여 드릴 게 요.

char s[3] = "0x1";
printf("s2   :
");
printf("%c
", s[0]);
printf("%c
", s[1]);
printf("%c
", s[2]);

2.포인터
포인터 도 변수 입 니 다.메모리 셀 에 다른 위 치 를 표시 하 는 주소 가 저장 되 어 있 을 뿐 주소 도 정수 입 니 다.32 비트 플랫폼 에서 32 비트,4 바이트(bytes)입 니 다.
포인터 의 방향
포인터 의 지향 은 포인터 변수 가 저장 한 다른 주소 셀 에 저 장 된 데이터 형식 을 말 합 니 다.
예 를 들 면:

int *ptr;//ptr                      
float *p;//  p                     

가리 키 는 데이터 형식 이 어떤 것 이 든 지 간 에 포인터 자체 의 값 은 영원히 정형 이다.왜냐하면 저 장 된 주 소 는 정수 이기 때문이다.
3.문자 배열
문자 배열 은 먼저 배열 이 고 배열 의 요 소 는 모두 문자 입 니 다.

char s[10];//       10      ，        %c

C 언어 에서 변 수 를 정의 할 때 초기 화 할 수 있 습 니 다.다음 과 같 습 니 다.

char s[10] = {"hello world"};

컴 파일 러 가 위의 정의 와 할당 을 만 났 을 때 hello World 와\0 을 연속 배열 메모리 에 차례대로 채 웁 니 다.
C 언어 에는 진정한 문자열 형식 이 없습니다.문자 배열 을 통 해 문자열 을 표시 할 수 있 고 문자 배열 의 요소 주소 도 연속 적 입 니 다.C 언어 에서 배열 이 있 는 메모리 위 치 를 대표 하 는 첫 번 째 주 소 를 규정 합 니 다.즉,str 문자열 은 str[0]과 같 습 니 다.str=&str[0];
printf("%s",str);왜 첫 주소 로 문자열 을 출력 할 수 있 습 니까?
C 언어 에서 문자열 상수 의 본질은 하나의 주소 이기 때 문 입 니 다.예 를 들 어:

char  *s ;
s = "Hello";

여기 서 하나의 문자열 을 문자열 포인터 변수 에 할당 합 니 다.처음에 C 언어 에서 컴 파일 러 는 문자열 에 상수 로 주 소 를 할당 합 니 다.만약 에'Hello'가 메모리 에 저 장 된 0x 3000 0x 3001 0x 3002 0x 3003 0x 3004 0x 3005 를 주면 진정한 의 미 를 알 수 있 습 니 다.
s = “Hello” = 0x3000
따라서 우 리 는 Hello 를 문자열 로 볼 수 있 고 컴 파일 러 는 그 를 주소 0x 3000,즉 문자열 상수 의 본질 이 첫 번 째 문 자 를 대표 하 는 주소 로 볼 수 있다.

char *s;
s = "Hello";
printf("%p
",s);//%p             ，        8  ，    0

00796 BD0 을 출력 합 니 다.즉,"Hello"의 첫 번 째 주소 입 니 다.
문자 배열:
char str[10] = “Hello”；
그 러 니까 str=&str[0]
C 언어 에서 문자열 을 조작 하 는 것 은 메모리 에 있 는 저장 장치 의 첫 주 소 를 통 해 이 루어 집 니 다.이것 은 문자열 의 궁극 적 인 본질 입 니 다.
4.char*와 char a[]
char*s 와 char a[]:
a 는 문자열 의 첫 번 째 주 소 를 대표 합 니 다.s 가 대표 하 는 이 지침 은 문자열 의 첫 번 째 주소(첫 번 째 문자 의 주소)를 저장 합 니 다.즉,s=a,즉 배열 이름 을 포인터 에 할당 하여 주 소 를 표시 할 수 있 지만 이렇게 할당 할 수 없습니다.a=s,즉 포인터 값 을 배열 이름 에 부여 할 수 없습니다.
배열 이름 은 상수 이기 때문에 수정 할 수 없습니다.
배열 요 소 를 다음 과 같이 접근 할 수 있 습 니 다.

char a[] = "Hello";
char*s = a;
int i;
for(i = 0;i < strlen(a);i++)
{
printf("%c",s[i]);
//printf("%c",*s++);   
}

문자 포인터 는 간접 연산 자*로 그 내용 을 가 져 올 수도 있 고 배열 의 아래 표 형식[]으로 도 사용 할 수 있 으 며 배열 이름 도*로 조작 할 수 있 습 니 다.그 자체 가 주 소 를 표시 하기 때 문 입 니 다.
예 를 들 어 printf("%c",*a);'H'가 인쇄 됩 니 다.
char*s 와 char a[]의 본질 적 차이
char a[10]를 정의 할 때 컴 파일 러 는 배열 에 10 개의 단원 을 배정 합 니 다.각 단원 의 데이터 형식 은 문자 이 고 char*s 를 정의 할 때 s 는 포인터 변수 로 4 개의 바이트,32 비트 만 차지 하 며 하나의 주 소 를 저장 합 니 다.
sizeof(a) = 10,sizeof(s) = 4
a 의 길 이 는 10 이 고 s 의 길 이 는 4 입 니 다.s 는 int 형 이기 때 문 입 니 다.
printf("%p",s)----이것 은 s 단원 에 저 장 된 주 소 를 표시 합 니 다.
printf("%p",&s);--------이것 은 변수 자체 가 있 는 메모리 단위 의 주 소 를 표시 합 니 다.헷 갈 리 지 마.
요약:char*s 는 문자열 의 첫 주 소 를 저장 하 는 포인터 변수 일 뿐 입 니 다.char a[]는 많은 연속 적 인 메모리 유닛 입 니 다.단원 의 요 소 는 char 형 입 니 다.char*와 char a[]는 같은 효 과 를 가 집 니 다.문자열 의 본질 에서 비롯 되 었 습 니 다.즉,문자열 주 소 를 주면 문자열 로 사용 할 수 있 지만 char*와 char a[]의 본질 적 인 속성 은 다 릅 니 다.
5.char**와 char*a[]
char *a[]
[]의 우선 순위 가*보다 높 기 때문에 먼저 a[]입 니 다.이것 은 하나의 배열 입 니 다.배열 의 요 소 는 char 형식 이 고 char 요 소 는 하나의 변수 이 며 주 소 를 저장 합 니 다.
char*a[]={"Dog","Cat","Chicken"};
배열 의 요 소 는 문자열 입 니 다.sizeof(a)는 12 입 니 다.4+4+8 이 아 닙 니 다.문자열 상수 의 본질 은 주소 이기 때 문 입 니 다.a 배열 의 요 소 는 char*포인터 이 고 포인터 변 수 는 정수 형식 입 니 다.4 개의 바이트 에서 3 개의 요 소 는 12 개의 바이트 입 니 다.

char *a[] = { "Dog","Cat","Chicken" };
printf("%p %p %p 
", a[0], a[1], a[2]);

세 개의 메모리 주 소 를 저장 한 배열 의 세 요 소 를 볼 수 있 습 니 다.이 세 개의 주 소 는 문자열 자체 가 아 닌 세 개의 문자열 의 첫 번 째 주 소 를 대표 합 니 다.또한 세 개의 주 소 는 연속 이 아 닙 니 다.컴 파일 러 가'Dog','Cat','Chicken'으로 분 배 된 메모리 공간 주소 이기 때문에 관련 이 없습니다.

char *a[] = { "Dog","Cat","Chicken" };
printf("           ：%p %p %p 
", &a[0], &a[1], &a[2]);//           

세 개의 요소 단원 이 있 는 주 소 는 연속 적 이 고 주소 마다 네 개의 바이트 차이 가 나 는 것 을 볼 수 있다.
char ** s
char**는 2 급 포인터 이 고 s 는 1 급 포인터 char*의 주 소 를 저장 합 니 다.
예 를 들 면:

char *a [ ] = { "Dog","Cat","Chicken" };
char **s =   a;//---   

배열 a 는 배열 요소 메모리 셀 의 첫 번 째 주 소 를 대표 합 니 다.즉,a=&a[0]=010 FFD 44,즉*s=001 D6BE 0="Dog"입 니 다.
이렇게 하면 s 를 통 해 a 의 데 이 터 를 방문 할 수 있 습 니 다.

printf(“%s”,*s);
printf("%s",a[0]);
printf("%s",*a);

세 개 는 같 지만 a=s 를 상수 이기 때문에
char **s = “hello world”; ------잘못된 것 이다.
s 의 유형 은 char**이 고'hello world'의 유형 은 char*이기 때 문 입 니 다.
모두 주소 지만 가리 키 는 유형 이 다 르 기 때문에 이렇게 사용 할 수 없습니다.그 본질 을 분석 하면'Hello World'는 하나의 주 소 를 대표 한다.예 를 들 어 0x 000001 이다.이 주소 의 내용 은'H'이 고 char 형 이 며 s 도 하나의 주 소 를 저장한다.이 주소 의 내용 은 char*이 고 지침 유형 이다.

char  **s;
*s = "hello world";

컴 파일 에 문제 가 없 지만 printf("%s",s)는 무 너 집 니 다.printf("%s",s);이 주소 에서 char*의 주소,즉*s 를 찾 아야 합 니 다.
만약 s=0x 1000;
0x 1000 이 있 는 메모리 셀 에"hello World"의 주 소 를 저장 합 니 다.0x 000001,*s=0x 000001.그러면 printf("%s",*s)는 먼저 0x 1000 을 찾 은 다음 에 0x 000001 을 찾 습 니 다.만약 에 char**s 를 직접 사용 하면*s="hello World"를 사용 합 니 다.s 변수 에 저 장 된 것 은 효과 가 없 는 무 작위 로 사용 할 수 없 는 값 입 니 다.그 가 어디 를 가리 키 는 지 모 르 기 때문에 char*s 를 사용 할 때...그 에 게 메모리 주 소 를 할당 해 야 한다.

char  **s ;
s = (char **) malloc(sizeof(char**));
*s =  "hello world";

이렇게 s 는 사용 가능 한 주소,s=0x 1234 를 할당 한 다음 에 0x 1234 가 있 는 메모리 의 위 치 를 입력 하여"hello World"의 값 을 저장 합 니 다.
다음 프로그램 에 서 는 문자 포인터 s 를 정의 하고 s 에 문자열'message'의 주 소 를 저장 합 니 다.

#include  <stdio.h>
void  buf( char **s)
{
 *s = "message";
}
int main()
{
 char *s ;
 buf(&s);
 printf("%s
",s);
}

즉,2 급 지침 은 1 급 지침 의 주 소 를 저장 합 니 다.그 유형 은 지침 변수 이 고 1 급 지침 은 데이터 가 있 는 메모리 유닛 을 가리 키 는 주 소 를 저장 합 니 다.
참고:
https://blog.csdn.net/daiyutage/article/details/8604720
6.C 언어 에서 char s[]와 char*s 의 차이
이 두 가지 차이 점 에 대해 다음 의 Stack Overflow 에서 온 설명 은 매우 뚜렷 하 다.
http://stackoverflow.com/questions/1704407/what-is-the-difference-between-char-s-and-char-s-in-c
The difference here is that
char *s = "Hello world";
will place Hello world in the read-only parts of the memory and making s a pointer to that, making any writing operation on this memory illegal . While doing:
char s[] = "Hello world";
puts the literal string in read-only memory and copies the string to newly allocated memory on the stack. Thus makings [0] = 'J' legal .
요약 하면 요점 은 다음 과 같다.
4.567917.4.567914.문자열 배열 을 정의 합 니 다.이 문자 배열 은 메모리 에 저 장 된 저장 소 는 먼저 새로운 공간 을 분배 한 다음 에 채 우 는 것 입 니 다.따라서 이 배열 의 내용 은 바 꿀 수 있 습 니 다.즉,4.567914 를 통 해 합 법 적 입 니 다4.567917.4.567914.문자열 포인터 변 수 를 정의 합 니 다.이 포인터 변 수 는 문자열 을 가리 키 며 이 포인터 의 값 은 이 문자열 이 메모리 에 있 는 주소 입 니 다.이 포인터 변 수 는 값 을 바 꿉 니 다=주 소 를 바 꿉 니 다=포인터 방향 을 바 꿉 니 다.예 를 들 어 첫 번 째 문자 에서 두 번 째 문 자 를 가리 키 는 것 입 니 다.그 다음 에 문자 포인터 변 수 를 바 꾸 는 것 은 그 가 가리 키 는 문자 의 값 을 바 꿀 권리 가 없다.예 를 들 어 4.567914.포인터 의 값 을 수정 할 수 는 있 지만 포인터 가 가리 키 는 값 은 수정 할 수 없다 는 얘 기다C 언어 char s[]와 char*s 의 차이 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 관련 C 언어 char s[]와 char*s 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 부 탁 드 리 겠 습 니 다!