Cómo usar el lenguaje C para hacer un bloc de notas
#includelt; stdio.hgt;
#includelt; malloc.hgt;
#includelt; includelt; stdlib.hgt;
#includelt;ctype.hgt;
#define NULL 0
#define MAX 100
typedef struct lnode{
char fecha[MAX]; //Datos de almacenamiento
struct lnode * anterior; //Predecesor
struct lnode * siguiente;
int number; //¡Registra el número de caracteres de un nodo! Si es el nodo principal, registre el número de sus nodos
int quese; // Registre la posición del nodo en la lista vinculada
}lnodetype; p> lnodetype * l ; //Establece dos variables globales, a saber, el puntero del nodo principal y el puntero del nodo final
lnodetype * end
//******* *****Esta función se utiliza para la inicialización **********//
int iniatelist (lnodetype ** l, lnodetype ** end)
{
(*l) = (lnodetype *)malloc (tamaño de (lnodetype) )
if ( (*l) == NULL )
; {
printf ("¡No hay suficiente espacio en la memoria! ¡El programa está a punto de cerrarse!"
return
}
);(*l)-gt; prior =(*l)-gt; next = NULL; //Esta es una lista doblemente enlazada
(*l)-gt; )-gt; quese = 0;
(*end) = (*l);
printf ("¡Inicialización del programa completada!"); 0;
}
p>//************Esta función se utiliza para crear nodos e insertar elementos ******* *****//
int enlace (lnodetype ** l, lnodetype ** end)
>
{
lnodetype *s;
s = (lnodetype *)malloc ( sizeof (lnodetype) )
if ( s == NULL; ){
printf ("Espacio de memoria insuficiente, ¡el programa está a punto de salir!"
return
}
s-gt; anterior = (*fin
(*fin) = (*fin)-gt; ;
p>
(*l)-gt; // Al agregar un nodo, el número del nodo principal aumenta en 1
s-gt; quese = (*l)-gt; number; / /Esto es para registrar la posición del nodo en la lista vinculada
printf ("d line", s-gt; quese); es registrar la posición del nodo en toda la lista vinculada
gets (s-gt; date
s -gt; number = strlen(s-gt; date); ;
return 0;
}
p>//************Esta es la función para imprimir el enlace lista************//
int prin (lnodetype ** l, lnodetype ** end)
{
lnodetype * p;
int i;
int j = 0;
int couter = (*l)-gt; p> p = (*l)-gt; siguiente;
for (i=0; i lt; couter ; i ){
printf ( "línea d", i 1 ) ;
j = 0;
mientras ( ( p-gt; fecha[j ]gt;='a' amp;amp; p-gt; fecha[j]lt ;='z') ||
(p-gt;date[j]gt;='A' amp;amp; p-gt;date[j]lt;='z') | |
p-gt;fecha[j]gt;='0' amp;amp; fecha[j]lt;='9')
{
printf( "c", p-gt; fecha[j] )
j ;
}
printf ("n");
p = p-gt;
}
devolver 0
}
//*********Esta función para buscar y editar la fila correspondiente**********//
int search (lnodetype ** l, lnodetype ** end)
{
int número
scanf ("d", amp; ; número);
int i;
lnodetype * p;
p = (*l)-gt; for (i=0; ilt; número-1; i)
p = p-gt; siguiente
printf ("línea d", número
);obtiene (p-gt; fecha);
devuelve 0
}
//********** *Esta es una función para buscar cadenas en archivos de texto **********//
int searchstr(lnodetype ** l, lnodetype ** end)
{
char ptr[100];
int arrycouter;
int mystrcmp(char *, char *, int); printf ( "¡ok! ¡Ahora ingresa la cadena que estás buscando!"
scanf ("s", ptr
arrycouter = strlen (ptr); >
lnodetype * s;
s = (*l)-gt; siguiente;
char * p; /p>
int contador = 0;
int número = (*l)-gt;
p = (char *)s-gt; /p>
mientras ( i amp; amp; número ){
// i=1 es, demuestra que no existe
Encontrado, continúa buscando el segundo nodo
while ( i amp; amp; ( ( (*p gt; = 'a') amp; amp; (*p lt; = 'z') ) | | ( (*p gt; = 'A') amp; amp; (*p lt; = 'Z') ) ) ){
i = mystrcmp ( p , ptr , arrycouter ); p>
if ( i == 1 ){
printf ("La cadena ya está en la línea d, comenzando en el carácter d", s-gt;quese, contador
i = 0;
}
else
{
p
contador; ;
i = 1;
}
}
s = s-gt; p = (char *)s-gt; fecha;
número --
}
si ( i == 1 )
printf ("¡La cadena no existe en este documento!");
return 0
}
//**** ***; ***(1) Esta función se utiliza para implementar la salida sin función de guardar************//
int exitunsave(lnodetype ** l, lnodetype ** end )
{
lnodetype * s;
while( (*l) != (*end) ){ //Si no se guarda, el último es mejor liberar todo el espacio de los nodos para ahorrar espacio
s = (*end
(*end) = (*end)-gt; p>
gratis( s );
}
devuelve 0;
}
//***** ** ***(2) Esta función se utiliza para implementar la función salir pero guardar************//
int quitandsave( lnodetype ** l , lnodetype * * fin )
{
ARCHIVO * fp;
char ch;
char nombre de archivo[20]; p> tipo de nodo
* p;
int i;
int j;
int couter = (*l)-gt; = (*l)-gt; next;
printf ("Ingrese el nombre del archivo:"); p > if ( (fp = fopen( nombre de archivo , "w")) == NULL ){
printf ("¡El archivo no se puede abrir! n");
return 0;
p>
}
for ( i=0; ilt; couter; i ){ //Almacenamiento tantas veces como nodos haya
ch = p- gt; fecha[0];
j = 1;
mientras (ch != '\0'){
fputc (ch , fp);
ch = p-gt; fecha[j];
j
p = p- gt; next;
fputc ( '#' , fp ); // Preste atención a agregar el símbolo final después de cada nodo
}
fputc ( ' @' , fp); // El signo de cerrar todo el archivo
fclose (fp); //Presta atención al cerrar el archivo,
return
}
//************Debido a que las funciones proporcionadas por la función de biblioteca para comparar cadenas no cumplen con los requisitos, escribí una yo mismo**** ********/
int mystrcmp( char * p , char * sour , int número )
{
while ( número amp. amplificador; (*p) == (*agrio) amplificador;
( ((*p gt; = 'a') amplificador; (*p lt; = 'z') ) || ((*p gt; = 'A') amp ;amp; (*p lt;= 'Z') ) )){
p
amargo ; /p>
número--
}
si ( número == 0 )
devolver 1;
más
devolver 0
}
//************ Esta función se utiliza para implementar la función de cadena estadística **********//
int coutword(lnodetype ** l, lnodetype ** end)
{ / /Considerando que no tiene sentido contar solo palabras en una línea, se cuenta todo el texto
int yes = 1 //Esta es una señal de ingresar una palabra
int no = 0; //En bandera fuera de palabra
int i, j, inaword, count = 0
inaword = no; = (*l) -gt; siguiente;
para (j=0; jlt; (*l)-gt; número; j ){
para (i=0; (s-gt; fecha[i]gt;='a' amp;amp; s-gt;fecha[i]lt;='z')
(s-gt;fecha[ i]gt;= 'A' &fecha[i]lt;='z') || ' & s-gt；fecha[i]lt；='9' ) ||
(s-gt；fecha[i]==' ');
{
if ( s-gt; fecha[i] == ' ' )
inaword = no
else
if (inaword == no)
{
inaword = yes
contar //Contar palabras
}
}
s = s-gt; next;
inaword = 0; // ¡Ten en cuenta que el indicador está establecido en 0!
}
printf ( "n texto-*** tiene d líneas", (*l)-gt; número
printf ("n); ¡Este texto tiene d palabras!" , count );
return count;
}
//******* ***Esta función se utiliza para implementar la función de calcular el número de líneas de texto************//
int linecouter(lnodetype ** l, lnodetype ** end)
{
int couter;
couter = (*l)-gt; /p>
return couter;
}
//**********Esta función es una función de menú que integra todas las funciones del primero* * ********//
int editmenu(lnodetype ** l , lnodetype ** end )
{
char elección; /p> p>
char * p = "cls"
int i = 1 ; //Estas dos variables se utilizan para controlar el bucle
int j= 1
sistema (p);
prin (amp; (*l), amp; (*end)); /p >
printf ("************************************ e: Edita el correspondiente línea*** **********************************n");
printf ("** ********************************** s: Cadena de búsqueda********* *** *************************n");
printf ("******* ******** ************************* t: Cuente el número de palabras************ ************ ****************n");
printf ("******** **************** **************** q: Salir de la edición*************** ********************** *******n");
scanf("c", amp; elección) ;
scanf("c", amp; elección); //Inexplicable ¡El problema requiere dos declaraciones de entrada de solicitud antes de detenerse!
cambiar (elección)
{
case 'e' : {
i = 1; mientras (i)
{
buscar( amp; (*l), amp; (*end) ); p> p>
imprimir(
amp;(*l), amp;(*end));
printf ("n1 continúa editando 0 y finaliza editando n"); ; i);
}
}
descanso;
caso 's': {
i = 1;
mientras (i)
{
searchstr( amp; (*l), amp; (*end)
);getchar();
getchar();
sistema (p
prin( amp; (*l), amp; (*); end ) );
printf ("n1 continúa buscando 0 y finaliza la búsqueda de n"); p> }
}
break;
case 't': {
coutword ( amp; (*l), amp ; (*fin) );
getchar();
}romper;
valor predeterminado:
}
p>
system (p);
prin( amp; (*l), amp; (*end)
printf ("n1 Volver al menú de edición 0 Finalizar edición n" );
scanf ("d", amp;j);
if (j == 1)
system (p);
más
devuelve 0
}
devuelve 0
}
int newtext( lnodetype ** l , lnodetype ** end )
{
printf ("Nuevo archivo de texto: n");
int i = 1; p> char judstr[MAX]
lnodetype * temp
char jud
<;p> char * p = "cls" ;
while ( 1 ){
enlace( amp; (*l) , amp; (*end)
;jud = (*end)-gt; date[0];
if (jud == '5'){ //Ingresa '5' para finalizar todo
temp = (*fin);
(*fin) = (*fin)-gt;
gratis (temperatura); ) {
printf ( "****************************** out: Salir sin guardar*** ************************n");
printf ( "********** ***** ************************* editar: editar información****************** ************* ***n");
printf ( "********************* **************** salir: Salir sin guardar****************************** *n");
printf ( "****** **************************** qas: Salir y guardar********************* ***********n");
printf ( "* ***************************** *** estafa: ¡Continúa escribiendo! ************* ****************n");
gets( judstr);
if ( !strcmp(judstr , "fuera") )
{
salirunsave( amp; (*l) , amp; (* end)
return 0; }
else
if ( !strcmp(judstr , "qas") )
{
quitandsave( amp; (*l ) , amp; (*end) )
return 0
}
else
if ( !strcmp(judstr , "editar") )
{
editarmenú (l
, fin);
devolver 0
}
sistema (p); 0;
}
}
devolver 0;
}
//***** *****Esta es la función para cargar archivos************//
int loadtaxt( char * filename )
{
ARCHIVO * fp;
lnodetype * l;
char
int i =
char; * p = "cls" ;
char judstr[MAX]
lnodetype * head
lnodetype * end
iniatelist; (amp; cabeza, amp; fin)
l = final = cabeza
if ((fp = fopen( nombre de archivo, "r")) == NULL ){
printf ("¡El archivo no se puede abrir! n");
return 0
}
ch = fgetc (fp);
while ( ch != '@' ){
lnodetype *s ;
s = (lnodetype *)malloc ( sizeof (lnodetype) ) ; /p>
if ( s == NULL ){
printf ("¡Espacio de memoria insuficiente, el programa está a punto de salir! ");
retorno 0;
}
end-gt; siguiente = s;
s-gt; anterior = fin
fin = fin-gt;siguiente
l-gt;número
s-gt;quese = l-gt;número
p>
p>
printf ("línea d", s-gt; quese
while (ch != '#'){
s-); gt; fecha[yo] =
ch ;
ch = fgetc (fp)
i
}
i = 0; > while ( (end-gt; fecha[i]gt; ='a' amp; amp; end-gt; fecha[i]lt; ='z') ||
(end-gt ;fecha[i]gt;='A' amp;amp; end-gt;date[i]lt;='z') || ='0' amp；amp; fin-gt；fecha[i]lt；='9' ) || >
{
printf ( "c", end-gt; fecha[i] )
i
}
<; p> end-gt; date[i] = '\0'; //Agregue esto al final del nodo para que la función de guardar salida sepa que este nodo ha finalizadoprintf ( "n " );
i = 0;
ch = fgetc (fp );
}
fclose (fp);
p>
printf ("¡n archivo cargado correctamente! n");
while (1){
printf ( "****** ****** ********************** out: Salir sin guardar****************** ****** ****n");
printf ( "*************************** ********** editar: Editar información******************************n");
printf ( "**** **************************** qas: Salir y guardar******** ********** **********n");
printf ( "**************** ************** ***** estafa: ¡Sigue escribiendo! *****************************n");
scanf("s", judstr);
if ( !strcmp(judstr , "out") )
{
exitunsave( amp; l , amp; end )
>
}
else
if ( !strcmp(judstr , "qas") )
{
quitandsave( amp ; l , amp; fin )
return 0
}
else
if (!strcmp(judstr , "editar) ") )
{
editarmenu (amp; l, amp; end);
devolver 0;
}
sistema (p);
}
devuelve 0;
}
//****** ****Función principal************//
void main ( void )
{
//iniatelist (amp;l, amp;end);
//newtext(amp;l, amp;end
nombre de archivo char[MAX]; scanf ( "s", nombre de archivo);
loadtaxt( nombre de archivo
}