Programa c de codificación Manchester

Manchester[1]='1';

j=2;

longitud externa;

for(i=0;ilt;length;i)

...{

// Datos de entrada del bucle

printf("actual el carácter es: c ", str0[i]);

// Procesamiento de bucle, 0 -gt; 01 1 -gt; 10

if(str0[i]==' 0') ...{Mánchester[j ]='0'; Mánchester[j ]='1';}

else if(str0[i]=='1') ...{ Manchester[j]='1'; Manchester[j]='0';}

else ...{printf("error de entrada, salida..."); // Error de entrada

// Datos después del procesamiento del bucle

printf("-----");

printf("después del proceso: cc " , Manchester[j-2], Manchester[j-1]);

}

// La cadena de resultado se agrega con un terminador

Manchester[ j]=0;

//Resultados de salida

printf("---------------------- -- ------------------- ");

printf("La codificación de Manchester es: s ", Manchester);

return 0;

}

int Dif_Manchester(char str0[]) //Codificación diferencial Manchester

...{

char Dif_Manch [2*M];

memset(Dif_Manch, 0, 2*M); //Inicializa la matriz

Dif_Manch[0]='0';

Dif_Manch[1]='1';

j=2;

longitud externa

for(i=0; ilt; longitud; i )

...{

// Datos de entrada del bucle

printf("el carácter actual es: c ", str0[i]);

// Procesamiento de bucle, 0 -gt; 01 1 -gt; 10

if(str0[i]

]=='0')

...{

Dif_Manch[j ]=Dif_Manch[j-3];

Dif_Manch[j ]=Dif_Manch [j-2];

}

si(str0[i]=='1')

...{

Dif_Manch[j ]=Dif_Manch[j-2];

Dif_Manch[j ]=Dif_Manch[j-3]

}

más . ..{printf("error de entrada, salida....."); return 1;} // Error de entrada

// Datos después del procesamiento del bucle

printf ("- ----");

printf("después del proceso: cc ",Dif_Manch[j-2],Dif_Manch[j-1]);

}

// La cadena de resultado más el símbolo del terminal

Dif_Manch[j]=0;

// Genera el resultado

printf(" -- ------------------------------------- ");

printf("La codificación de Dif_Manchester es: s ", Dif_Manch

devuelve

}

/**////// /////////////////////////////////////////////////// //// //////////////////////////////////////////////// //////// ////////////////

//////////////////// /////////// /////////////////////////////////////// ///////////////

//Punto de entrada

int main(int argc, char* argv[])

...{

char str0 [M];

// Obtener datos de entrada

printf("ingrese la cadena numérica que desea (it debe ser menor que 10): ");

scanf("s", str0);

// Para verificar si los datos de entrada son correctos, puede usar afirmar o similar

printf("lo que ingresaste------ :: s ", str0

length=strlen(str0); (length lt; M ); //Establece aserción, verificación de matriz fuera de límites

// Establece el área de datos de salida en 0

//memset(str1, 0, 2*M);

Direct_code(str0);

Manchester( str0);

Dif_Manchester(str0);

devuelve 0 ;<

/p>

}

/**////////////////////////////////// // ///////////////////////////////////////////////// /

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/**///////////////////////////////////////// // /Este es un programa que acabo de empezar a escribir yo mismo////////////////////////////////////// /////// ////////////////////////////////

#definir M 10

# includelt; stdio.hgt;

void main()

...{

int i=0; p>

int str0[ M];

int str1[2*M];

printf("ingrese la cadena numérica que desea: ");

scanf("s ", str0);

hacer

...{

if(str0[i]==0) . ..{str1[i]= 0; str1[i 1]=1;}

else if(str0[i]==1) ...{str1[i]=1; i 1]=0;}

i ;

} while(str0[i]!='

... . . . . son diferentes. Por ejemplo, '1' y '0' representan caracteres, mientras que 1 y 0 representan números (pero hay una pregunta que todavía no entiendo. ¿Hay algún problema con almacenar números en una matriz? ¿Por qué usar caracteres? Jaja, no No me regañes...). Cuando un carácter se representa con '', lo que transmite al ordenador es su valor en código ASCII.

B: Al escribir un programa, se debe tener claro qué es cada pieza. del código lo hace. Claramente, establezca una determinada salida de aviso para mostrar lo que hace el programa. La estructura debe ser clara. ¿Qué resultados se obtienen de cada procesamiento de datos? Claramente quiero saber qué hizo en cada paso del procesamiento de datos. >

C: El punto importante es que antes de escribir un programa, debes tener una idea muy clara en mente. Dibujar un diagrama de flujo es el punto clave. A menudo empiezo a escribir con prisa antes de haber descubierto qué es. Está sucediendo y el progreso es muy lento. Lento "El problema es que no has aclarado el problema primero y no has aclarado los procesos de entrada, procesamiento de entrada y salida en tu cabeza".

D: Problema personal: No puedes poner la misma cantidad de energía que tiempo. No es que no quiera aunque estoy muy concentrado, sé que todavía estoy pensando en otras cosas. mi cabeza, y no la he aclarado antes de escribir el programa.

Además, no estoy lo suficientemente atento para hacer las cosas y soy poco entusiasta: cuando escribo un programa, puedo estar leyendo una página web u otras cosas al mismo tiempo. Problema que no entiendo, buscaré en línea durante mucho tiempo y tomaré un gran desvío para regresar. Aunque entendí lo que no entendí, lo que estaba haciendo actualmente fue interrumpido.

E: He escrito tres programas relativamente completos hasta ahora, y ninguno de ellos es fácil. No es que el programa sea difícil, pero no es fácil para mí escribirlo; Puede que no sea bueno programando

F: De repente recordé un defecto fatal de ziji: la procrastinación.

G: Suplemento: Esto es solo una simulación. De hecho, la codificación Manchester debe corresponder a la operación de bits AND

//////////////. //// //////////////////////////////////////////////// //////// /////////////////////////////////////////// //////////// /////////////////////////////////////

Nuevo punto de conocimiento uno: ASSERT()

ASSERT() es una macro que se utiliza a menudo al depurar programas.

assert es una función que verifica si la expresión entre paréntesis después de afirmar es verdadera. Si es falsa, se informará un error cuando se ejecute el programa.

Al construir una aplicación. , siempre debe recordar: cuando ocurre un error o un error inesperado, se debe permitir que el programa muera repentinamente lo antes posible. Hacer esto puede ayudarle a detectar errores en las primeras etapas del ciclo de desarrollo y prueba. Los errores que no provocan una muerte súbita son difíciles de detectar; a menudo se ignoran y no se detectan hasta que el programa se ejecuta en un sistema cliente.

La forma más sencilla de comprobar si hay condiciones inesperadas es a través de la macro de afirmación de la biblioteca C estándar. El parámetro de esta macro es una expresión booleana. Cuando el valor de la expresión es falso, afirmar generará el nombre del archivo fuente, el número de línea de error y el contenido literal de la expresión, y luego hará que el programa se cierre. La macro Assert se puede utilizar en una gran cantidad de situaciones donde se requieren comprobaciones de coherencia dentro de un programa. Por ejemplo, puede utilizar afirmar para verificar la legalidad de los parámetros del programa, verificar las condiciones previas y el estado final (condición posterior) de funciones (o métodos de clase en C), verificar valores de retorno de funciones inesperados, etc.

Cada vez que utiliza la macro de afirmación, no solo puede usarse como verificación del tiempo de ejecución, sino que también puede considerarse como un documento incrustado en el código para especificar el comportamiento del programa. Si su programa contiene afirmar (condición), le está diciendo a la persona que lee el código que la condición siempre debe cumplirse aquí; de lo contrario, es probable que se trate de un error en el programa;

Para el código donde la eficiencia es primordial, las comprobaciones en tiempo de ejecución como la afirmación pueden causar graves pérdidas de eficiencia. En este caso, puede definir la macro NDEBUG y recompilar el código fuente (esto se puede hacer agregando el parámetro –DNDEBUG a los parámetros del compilador). En este caso, el preprocesador borrará el contenido de la macro de afirmación. Los archivos que contienen código que prioriza la eficiencia deben compilarse con la macro NDEBUG solo cuando la eficiencia deba ser una prioridad.

Debido a que la afirmación puede borrarse mediante preprocesamiento, debe asegurarse de que la expresión condicional no tenga efectos secundarios al usar esta macro. En particular, estas declaraciones no deben usarse en la expresión condicional de afirmación: llamadas a funciones, asignación de valores a variables y uso de operadores que modifican variables (como, etc.).

Por ejemplo, supongamos que llamas a la función hacer_algo repetidamente en un bucle. Esta función devuelve 0 en caso de éxito y un valor distinto de cero en caso de error. Pero no espera que falle en absoluto en su programa. Quizás quieras escribir algo como esto:

for (i = 0; i lt; 100; i)

afirmar (hacer_algo () == 0);

Sin embargo, es posible que esta verificación del tiempo de ejecución introduzca un impacto inaceptable en el rendimiento y, por lo tanto, decida especificar más adelante NDEBUG para deshabilitar la verificación del tiempo de ejecución.

El resultado de esto es que toda la llamada a afirmar se eliminará por completo, es decir, la expresión condicional de la macro de afirmación nunca se ejecutará y nunca se llamará a do_something una vez. Por tanto, es correcto escribir así:

for (i = 0; i lt; 100; i) {

int status = hacer_algo();

afirmar (estado == 0);

}

Otra cosa para recordar es que afirmar no debe usarse para detectar entradas ilegales del usuario. Los usuarios no quieren ver un fallo del programa sólo para generar algún mensaje de error vago incluso después de ingresar información inapropiada. Debe verificar si hay entradas ilegales por parte del usuario y devolverle un mensaje de error comprensible. La macro de afirmación solo debe usarse cuando se realizan comprobaciones de tiempo de ejecución dentro del programa.

Algunos lugares recomendados para usar la macro de afirmación:

Verifique la legalidad de los parámetros de la función, como determinar si es un puntero NULL. Salida de error de { afirmar (puntero != NULL)}

La afirmación 'puntero != ((void *)0)' falló.

Y cuando el programa falla debido a un NULL pointer El mensaje de error obtenido al desreferenciar

Fallo de segmentación (núcleo volcado)

es mucho más claro en comparación.

? Comprobar los valores de los parámetros de la función. Por ejemplo, cuando el parámetro foo de una función debe ser positivo podemos hacer una comprobación como esta al principio de la función:

afirmar (foo gt; 0

This); le ayudará a encontrar la llamada incorrecta; al mismo tiempo, le indicará claramente a la persona que lee el código: esta función tiene requisitos especiales para el valor del parámetro.

No cedas; utiliza macros de afirmación cuando sea apropiado en tus programas.

Utilice Assertion para mejorar la confiabilidad de su código

Las siguientes son cuatro situaciones de uso de aserción y sus ejemplos correspondientes. Estos métodos pueden hacer que los programas Java sean más confiables.

1. Verifique el flujo de control; en las declaraciones if-then-else y switch-case, podemos agregar declaraciones afirmativas falsas a los afluentes de control que no deberían ocurrir. Si esto sucede, afirmar puede comprobarlo.

Por ejemplo: el valor de x solo puede ser 1, 2, 3. Nuestro programa se puede expresar de la siguiente manera

switch (x)

{ case 1: … ;

caso 2: …;

caso 3: …

predeterminado: afirmar falso: "el valor x no es válido: " x;

}

2. Antes de calcular la función privada, verifique si los parámetros de entrada son válidos para algunas funciones privadas, la entrada debe cumplir algunas condiciones específicas, luego podemos usar afirmar en; el comienzo de la función para comprobar los parámetros. Para las funciones públicas, normalmente no utilizamos la verificación de aserciones porque, en términos generales, las funciones públicas deben verificar y manejar parámetros no válidos. Las funciones privadas suelen utilizarse directamente.

Por ejemplo: una función puede requerir que los parámetros de entrada no sean nulos.

Luego podemos agregar afirmar parámetro1!=null al comienzo de la función: "el parámetro es nulo en el método de prueba";

3. Después del cálculo de la función, verifique si el resultado de la función es válido para algún cálculo; funciones, una vez completada la función, ciertos valores deben garantizar ciertas propiedades, por lo que podemos verificar el valor mediante afirmar.

Por ejemplo, si tenemos una función que calcula el valor absoluto, entonces podemos agregar una declaración al resultado de la función:

afirmar valorgt;=0: "El valor debe ser mayor que 0: " valor;

De esta forma podemos comprobar el resultado del cálculo de la función.

4. Verifique las invariantes del programa; en algunos programas, hay algunas invariantes y los valores de estas invariantes permanecen sin cambios durante el ciclo de vida del programa. Estas invariantes pueden ser una expresión simple o una expresión compleja. Para algunas invariantes clave, podemos verificar mediante afirmar.

Por ejemplo, en un sistema de contabilidad financiera, los gastos e ingresos de la empresa deben mantener un cierto equilibrio, por lo que podemos escribir una expresión para comprobar este saldo, como se muestra a continuación.

private boolean isBalance() {

…

}

En este sistema, hay algunas cosas que pueden afectar esta relación de saldo Antes y después del método, podemos agregar verificación de aserción: afirmar isBalance(): "el saldo se destruye";

//////////////////// /////////////////////////////////////////////////// /// ///////////////////////////

Nuevo punto de conocimiento (2) memset

. void *memset(void *s, int c, size_t n)

Función total: establece el valor de los primeros n bytes del espacio de memoria abierto s al valor c.

2. Ejemplo

#i nclude

#i nclude

main(){

char *s="Golden Global View";

clrscr();

memset(s,'G',6);

printf("s", s);

getchar();

devuelve 0;

}

3. La función memset() se utiliza a menudo para inicializar el espacio de memoria. Por ejemplo:

char str[100];

memset(str, 0, 100); La connotación profunda de memset(): se usa para establecer todo el espacio de memoria en un determinado carácter, generalmente se usa para inicializar la cadena definida en ' ' o '\0'; ejemplo: char a[100]; 0', sizeof(a));

memcpy se usa para copiar memoria. Puede usarlo para copiar objetos de cualquier tipo de datos y puede especificar la longitud de los datos de la copia, por ejemplo: char; a[100], b[50]; memcpy(b, a, sizeof(b)); tenga en cuenta que el uso de sizeof(a) hará que la dirección de memoria de b se desborde.

strcpy solo puede copiar cadenas. Finalizará la copia cuando encuentre '\0'; por ejemplo: char a[100], b[50]; (b, a), preste atención a si la longitud de la cadena en a (antes del primer '\0') excede los 50 dígitos, si excede, hará que la dirección de memoria de b se desborde.

5. Suplemento: la experiencia de alguien

memset puede borrar convenientemente una variable o matriz de un tipo de estructura.

Por ejemplo:

struct sample_struct

{

char csName[16]

int iSeq;

int iType;

};

Para variables

struct sample_strcut stTest;

En circunstancias normales, borrar el método stTest:

stTest.csName[0]='\0';

stTest.iSeq=0;

stTest.iType=0;

Es muy conveniente usar memset:

memset(amp; stTest, 0, sizeof(struct sample_struct));

Si es una matriz:

struct sample_struct TEST[10];

Entonces

memset(TEST, 0, sizeof(struct sample_struct)*10);

6. strcpy

Prototipo: extern char *strcpy(char *dest, char *src);

Uso: #i nclude

Función: cambiar el src señalado por La cadena terminada en NULL se copia en la matriz a la que apunta dest.

Nota: Las áreas de memoria a las que apuntan src y dest no pueden superponerse y dest debe tener suficiente espacio para acomodar la cadena de src.

Devuelve un puntero al destino.

memcpy

Prototipo: extern void *memcpy(void *dest, void *src, unsigned int count);

Uso: #i nclude

Función: Copiar bytes de recuento desde el área de memoria señalada por src al área de memoria señalada por destino.

Nota: Las áreas de memoria apuntadas por src y dest no pueden superponerse y la función devuelve un puntero a dest.

memset

Prototipo: extern void *memset(void *buffer, int c, int count);

Uso: #i nclude

Función: Establece el primer recuento de bytes del área de memoria señalada por el búfer en el carácter c.

Descripción: Devuelve el puntero al buffer.