detalles de la cadena del idioma c

1. Cadena literal.

"El caramelo \ nEs excelente \ nPero el licor \ nEs más rápido".

Se llama literal de cadena en C ++. Puede incrustar la secuencia de transferencia dentro de la cadena, como '\ n'

Tenga cuidado de incrustar las secuencias de transferencia octal y hexadecimal en la cadena. La secuencia de transferencia octal comienza con /, la secuencia de transferencia hexadecimal comienza con / x (x debe ser minúscula) y la secuencia de transferencia octal es de tres dígitos (debe estar dentro del rango de 0-7) Termina después o termina con el primer número no octal (el número es mayor o igual a 8 y termina).

No hay restricción después de hexadecimal / x, y termina con el primer dígito no hexadecimal (mayor que f). Tenga en cuenta que los números hexadecimales se pueden escribir con mayúscula (obtenidos de los resultados del compilador). Por ejemplo, mire el siguiente código:

#include <stdio.h>
int main()
{
if(('\xAA') ==  ('\xaa'))
        printf("equal");
else 
        printf("not equal.");
    return 0;
}

El resultado de la operación es:

equal

2. Continúe con la cadena literal.

(1) Método 1: Utilice \

Por ejemplo, "soy un estudiante \

   y tu eres maestra. "

Características: La primera línea termina con \ (no incluida) y la segunda línea comienza al principio de la línea.

(2) Método 2: cuando dos o más cadenas son adyacentes, el lenguaje C fusionará automáticamente las cadenas. Usa esta regla para escribir así

"soy un estudiante "

"y tu eres maestra".

Finalmente, el compilador fusionará las cadenas en sí. "Yo soy un estudiante y tu eres un maestro".

3. Almacenamiento de cadenas literales. El lenguaje C almacena literales de cadena como matrices de caracteres. Cuando el lenguaje c encuentra una cadena de longitud n, asignará un espacio de memoria de longitud n + 1 para la cadena literal y agregará '\ 0' al final. Nota: No confunda '\ 0', '0' y '' aquí. El valor del código del carácter nulo es 0 y el valor del código de '0' (ASCII) es 48, y el valor del código del espacio '' ASCll es 32. Recuerde, si la matriz de caracteres se inicializa por defecto, será '\ 0'.

Cuando la matriz de caracteres se inicializa de forma predeterminada, a cada carácter también se le asigna un valor de '\ 0' en lugar de la barra espaciadora, y cada dígito de la matriz de tipo aritmético se inicializa a 0.

La cadena vacía es "", la cadena vacía se almacena como un solo carácter vacío, '\ 0'

La cadena se almacena literalmente como una matriz, por lo que la cadena se tratará literalmente como un puntero (el nombre de la matriz se tratará como un puntero). Por ejemplo, printf ("abcde"); luego se pasará la cadena "abcde" a la función printf La dirección (es decir, el puntero a la unidad de memoria del carácter a).

4. Los literales de cadena se tratarán como punteros.

Por ejemplo, "abc"

printf ("abc"); Aquí, "abc" se considerará como un puntero a la unidad de memoria de la letra a.

Tanto printf como scanf aceptan char * type como su primer parámetro.

5. Operación de cadenas literales.

(1) El valor literal de la cadena de caracteres no se puede cambiar. Mira el siguiente código:

#include <stdio.h>
int main()
{
char *str = "abcde";
*str = 'a';
printf("%s",str);
   return 0;
}                                                                         
                

Se produjo un error de tiempo de ejecución en el resultado de ejecución:

r@r:~/coml_/c/13/2$ gcc 3.c -o 123
r@r:~/coml_/c/13/2$ ./123
Segmentation fault (core dumped)
r@r:~/coml_/c/13/2$ 

Conclusión: el contenido del literal de cadena no se puede cambiar. Pero puede hacer que el objeto char * apunte a otra cadena, por ejemplo,

#include <stdio.h>
int main()
{
char *str = "abcde";
printf("%s\n",str);
//str 重新指向另一个字符串字面量
str = "efghikasdfasd fasdf asdf asdf asf";
printf("%s",str);
return 0;

Los resultados son los siguientes:

abcde
efghikasdfasd fasdf asdf asdf asfr

Lugar inesperado: Puede exceder la longitud de la cadena original.

(2) En la mitad de los casos, puede usar cadenas literales siempre que se necesite char *.

Por ejemplo, char * p;

p = "abc"; Esta operación no es para copiar la cadena, sino para asignar la dirección del carácter a ap, es decir, el proceso de asignación de la variable puntero p, no todo el proceso de asignación de la cadena.

(3) Los punteros tienen operaciones de subíndice y los literales de cadena también tienen

"abc" [1] se refiere al carácter b

La siguiente función convierte números enteros en caracteres hexadecimales.

char number_to_hex(int n)
{
return "0123456789ABCDEF"
}                                                                         
  

(4) Nota aquí hexadecimal y octal número y secuencia de transferencia no es lo mismo

          (a) La definición de número hexadecimal \ x00 ( x es mayúscula y minúscula, la parte numérica no tiene requisitos de longitud ), la definición de número octal, \ 012 (el comienzo del número 0 es un número octal, y el número después de \ 0 no tiene límite de longitud )

         (b) La secuencia de escape hexadecimal debe comenzar con \ x ( x debe estar en minúsculas y los siguientes dígitos deben tener como máximo 2 dígitos de 0 a ff ), y la secuencia de transferencia octal debe comenzar con \ , y los siguientes dígitos deben ser 3 dígitos como máximo . Consulte la siguiente figura. Revise

6. Los literales de cadena y las constantes de caracteres no se pueden intercambiar, consulte el siguiente código:

#include <stdio.h>
int main()
{
printf("\n");
printf('\n');  //这里引发错误
    return 0;
}        

Los resultados de la compilación del compilador gcc son los siguientes:

r@r:~/coml_/c/13/2$ gcc 4.c -o 123
4.c: In function ‘main’:
4.c:5:8: warning: passing argument 1 of ‘printf’ makes pointer from integer without a cast [-Wint-conversion]
    5 | printf('\n');
      |        ^~~~
      |        |
      |        int
In file included from 4.c:1:
/usr/include/stdio.h:332:43: note: expected ‘const char * restrict’ but argument is of type ‘int’
  332 | extern int printf (const char *__restrict __format, ...);
      |                    ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~
4.c:5:1: warning: format not a string literal and no format arguments [-Wformat-security]
    5 | printf('\n');

7. Variables de cadena. Tenga en cuenta que debe terminar con "\ 0", de lo contrario, se producirá un comportamiento indefinido cuando las funciones de la biblioteca lo llamen.

#include <stdio.h>
#define STR_LEN 20
int main()
{
//方法1：直接定义成字符数组+初始化
char str[STR_LEN + 1] = "you are welcome.";
//方法2：直接定义为char * + 初始化
char * str1 = "you are welcome.";
//方法3：先定义一个字符数组,和一个char *,把char *对象指向一个char 数组
char str2[STR_LEN + 1],*str3;
str3 = str2;
//方法4:先定义一个char *，后来可以指向一个字符串字面值
char *ptr;
ptr = "you are welcome";
puts(ptr);
  return 0;
}

Pero si desea usar scanf para leer char *, primero debe abrir suficiente espacio, es decir, primero debe declarar el tipo como char [STR_LEN + 1], pero no como el tipo char *.

char * p; // Solo lo suficiente para que el puntero p almacene un espacio de puntero. No se puede asignar espacio para la cadena. Si usa p para leer, causará un error:

#include <stdio.h>
int main()
{
char *p;
scanf("%s",p);
printf("%s",p);
  return 0;
}

Los resultados de la operación son los siguientes: después de haber ingresado su aresdf como se requiere, la salida es nula

you arasdf
(null)

8. Inicializar variables de cadena

Cuando el lenguaje c maneja la fórmula de inicialización de la matriz, cuando la fórmula de inicialización de la matriz es acortada por la propia matriz, los elementos restantes de la matriz se inicializarán a 0 (los elementos son int, float, double) y la matriz char sigue las mismas reglas . '\ 0' agregado.

No importa si asigna un valor a char * o char [] (el tipo de valor es un literal de cadena), se agregará automáticamente con '\ 0' al final

#include <stdio.h>
int main()
{
double d[12] = {0.0};
int i;
for(i = 0; i!= 12; ++i)
{
printf("%f\n",d[i]);
}
   return 0;
}
~   

Los resultados son los siguientes:

0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000

9. Matriz de caracteres y puntero de caracteres

Similitudes: siempre que se acepten matrices de caracteres o punteros de caracteres, ambos se pueden utilizar como parámetros reales.

diferencia:

(1) La matriz de caracteres puede modificar el valor de un carácter, pero el puntero de carácter no puede modificar el valor literal de la cadena.

(2) El nombre de la matriz de caracteres es el nombre de la matriz y el puntero de carácter es una variable que puede apuntar a otras cadenas durante la ejecución.

Por ejemplo, char * p, donde p es una variable de puntero que apunta a un objeto char. El valor de p se puede cambiar, solo eso (el objeto apuntado por p no se puede cambiar, distinguir * p = ... (ilegal) y p = ... (legal))

char * p;

p = "abcde"; // Legal, aquí está el valor de p cambiado. p es una variable, por supuesto que se puede cambiar.

* p = "efghi"; // Ilegal, si desea cambiar el literal de cadena apuntado por p, se informará un error.

 

10. Lectura y escritura de cadenas

(1) Leer

Utilice scanf o fget ();

Características: Se ignorarán todos los espacios en blanco después del comienzo. Por ejemplo, si ingresa un bc def, los espacios en blanco del comienzo se ignorarán y se leerá a al final, y algunos de estos últimos se almacenarán en caché en la memoria, esperando para lecturas posteriores.

(2) Escribir

                 printf ("") saldrá estrictamente uno por uno hasta que se encuentre el primer '\ 0'. Si no hay '\ 0' al final de la cadena, continuará escribiendo hasta el primer '\ 0' en se encuentra la memoria. 0 '.

                put (), agregará un '\ n' directamente al final de la línea (ajuste automático)

(3) Los problemas a resolver escribiendo la función de cadena de lectura son los siguientes

   (a) Cuándo comenzar a leer (si ignorar el carácter inicial en blanco) (b) Cómo terminar '\ n', el espacio sigue siendo un carácter determinado, si el carácter final debe escribirse en la cadena (c) Si el La cadena de lectura es demasiado larga, los caracteres adicionales se ignoran directamente o se dejan para la siguiente operación de entrada.

Por ejemplo, si el carácter de nueva línea no se ignora, el primer carácter de nueva línea termina y el carácter de nueva línea no existe en la cadena, entonces escriba la función read () en el código de la siguiente manera:

#include <stdio.h>
#define LEN 20
int read(char str[],int n);
void print(char str[],int n);
int main()
{
char array[LEN + 1] = {' '};
read(array,LEN);
print(array,LEN+1);
    return 0;
}
int read(char str[],int n)
{
char ch;
char *p = str;
int i = 0;
while((ch = getchar()) != '\n')
{
 if(i < n)
 { *p ++ = ch;
     i++;
  }
}
*p = '\0';
return i;

}
void print(char str[],int n)
{
int i = 0;
for(i = 0; i!= n; ++i)
  {
    printf("%c",str[i]);
  }
}

                   La función read () también se puede escribir simplemente de la siguiente manera:

int read(char str[],int n)
{int i = 0;
char ch;
  while((ch = getchar()) != '\n')
  {
  if(i < n)
      str[i ++] = ch;
  }
  str[i] = '\0';  //terminates string
  return i;       //number of characters stored
}

La función scanf y la función gets agregarán automáticamente un carácter nulo al final.Sin embargo, si escribe una función usted mismo, debe agregar un carácter nulo usted mismo.