hogar / POR/ Programación en C (C) en Ubuntu (Linux). Introducción

Programación en C (C) en Ubuntu (Linux). Introducción

Todas las acciones en el sistema operativo se realizan mediante programas, por lo que muchos principiantes están interesados no solo en utilizar los programas de otras personas, sino también en escribir los suyos propios. Muchos quieren contribuir a la base de código OpenSource.

Este es un artículo de descripción general sobre la programación de Linux. Consideraremos qué idiomas se usan con mayor frecuencia, consideraremos los conceptos básicos, así como las posibilidades, analizaremos cómo escribir el programa mas simple en uno de los lenguajes de programación más populares, cómo compilarlo y ejecutarlo manualmente.

Históricamente, el kernel de Unix se escribía en C. Aún más que eso, este lenguaje fue creado para escribir el kernel de Unix. Dado que el kernel de Linux se basó en el kernel Minix (una versión de Unix), también se escribió en C. Por tanto, podemos decir que el principal lenguaje de programación para Linux es C y C++. Esta tendencia continuó durante mucho tiempo.

En general, puede escribir programas para Linux en casi cualquier idioma, desde Java y Python hasta C # e incluso Pascal. Todos los lenguajes tienen compiladores e intérpretes. Escribir programas en C++ es difícil, y muchos ya consideran que C es obsoleto, por lo que muchos programadores usan otros lenguajes para escribir programas. Por ejemplo, muchas herramientas del sistema están escritas en Python o Perl. La mayoría de los programas de comandos de linux Mint, el instalador de Ubuntu y algunos scripts aptos están escritos en Python. Muchos scripts, incluidos los scripts de optimización simples, están escritos en Perl. A veces, Ruby se usa para secuencias de comandos. Estos son scripts de OpenShift o, por ejemplo, el marco Metasploit. Algunos desarrolladores multiplataforma usan Java. Pero los componentes principales del sistema todavía están escritos en C.

No cubriremos los conceptos básicos de C en este artículo. C es un lenguaje complejo y necesitarás leer al menos un libro y practicar mucho para dominarlo. Veremos cómo escribir programas C en Linux, cómo construirlos y ejecutarlos.

Por qué aprender C:

2. Bibliotecas

Naturalmente, si necesita mostrar una cadena o una imagen en la pantalla, no accederá directamente a la tarjeta de video. Simplemente llama a algunas funciones que ya están implementadas en el sistema y les pasa los datos que desea mostrar. Tales funciones se colocan en las bibliotecas. De hecho, las bibliotecas son colecciones de funciones que utilizan otros programas. Contienen el mismo código que en otros programas, la única diferencia es que no existe necesariamente la presencia de una función de inicialización.

Las bibliotecas se dividen en dos tipos:

Estático- están vinculados al programa en la etapa de compilación, están vinculados y después de eso, todas las funciones de la biblioteca están disponibles en el programa como funciones nativas. Estas bibliotecas tienen la extensión .a;
Dinámica- tales bibliotecas son mucho más comunes, se cargan en la RAM y se vinculan dinámicamente al programa. Cuando un programa necesita una biblioteca, simplemente la llama a una dirección conocida en memoria de acceso aleatorio. Esto ahorra memoria. La extensión de estas bibliotecas es .so, que es similar a Shared Object.

Por lo tanto, para cualquier programa en C, debe incluir bibliotecas, y todos los programas usan algún tipo de biblioteca. También es importante tener en cuenta que no importa en qué idioma decidas escribir, al final todo se reducirá a las bibliotecas del sistema C. Por ejemplo, escribe un programa en Python, usa las funciones estándar de este lenguaje y el intérprete en sí ya es un programa C / C ++ que usa bibliotecas del sistema para acceder a las funciones principales. Por lo tanto, es importante comprender cómo funcionan los programas en C. Por supuesto, hay lenguajes como Go que se traducen inmediatamente a ensamblador, pero los principios son los mismos que aquí. Además, la programación del sistema Linux es principalmente C o C++.

3. Proceso de montaje del programa

Antes de pasar a la práctica y crear nuestro primer programa, debemos comprender cómo se lleva a cabo el proceso de ensamblaje, en qué etapas consiste.

Cada programa serio consta de muchos archivos, estos son archivos fuente con extensión .c y archivos de encabezado con extensión .h. Estos archivos de encabezado contienen funciones que se importan al programa desde bibliotecas u otros archivos.c. Antes. cómo el compilador puede compilar el programa y prepararlo para el trabajo, debe verificar si todas las funciones están realmente implementadas, si todas las bibliotecas estáticas están disponibles y compilarlas en un solo archivo. Por lo tanto, primero se ejecuta el preprocesador, que construye el archivo fuente, se ejecutan sentencias como include para incluir el código de los archivos de cabecera.

En la siguiente etapa, el compilador comienza a funcionar, realiza todas las acciones necesarias en el código, analiza las construcciones sintácticas del lenguaje, las variables y convierte todo esto en un código intermedio, y luego en el código de instrucciones de máquina, que podemos luego mira en lenguaje ensamblador. El programa en esta etapa se denomina módulo de objeto y aún no está listo para ejecutarse.

A continuación, el enlazador se pone a trabajar. Su tarea es vincular el módulo de objetos con bibliotecas estáticas y otros módulos de objetos. Se crea un módulo de objeto independiente para cada archivo de origen. Solo ahora se puede iniciar el programa.

Y ahora, veamos todo el proceso en la práctica usando el compilador GCC.

4. Cómo construir el programa

Hay dos tipos de compiladores que se utilizan para construir programas en Linux, estos son . Hasta ahora, GCC es más común, así que lo consideraremos. Por lo general, el programa ya está instalado en su sistema, si no, puede ejecutarlo para instalarlo en Ubuntu:

sudo apt instalar gcc

Antes de pasar a escribir y compilar el programa, veamos la sintaxis y las opciones del compilador:

$ gcc opciones archivo_fuente_1.c -o archivo_terminado

Con la ayuda de opciones, le decimos a la utilidad qué hacer, qué bibliotecas usar, luego simplemente especificamos los archivos fuente del programa. Veamos las opciones que usaremos hoy:

-o- escribir el resultado en un archivo para la salida;
-C- crear un archivo de objeto;
-X- especificar el tipo de archivo;
-l- cargar biblioteca estática.

En realidad, esto es todo lo más básico que necesitamos. Ahora vamos a crear nuestro primer programa. Imprimirá una línea de texto en la pantalla y, para hacerlo más interesante, sacará la raíz cuadrada de 9. Aquí está el código fuente:

incluir
#incluir

int principal()(
printf("sitio\n");
printf("Raíz: %f\n", sqrt(9));
devolver 0;
}

gcc -c programa.c -o programa.o

Esta es la etapa de compilación, si no hay errores en el programa, tendrá éxito. Si hay varios archivos de origen, dicho comando se ejecuta para cada uno de ellos. A continuación hacemos el enlace:

gcc -lm programa.o -o programa

Preste atención a la opción -l, con ella especificamos qué bibliotecas deben incluirse, por ejemplo, aquí incluimos la biblioteca de funciones matemáticas, de lo contrario, el enlazador simplemente no encontrará dónde está esta o aquella función. Solo después de eso puede ejecutar el programa para su ejecución:

Por supuesto, todas estas acciones se pueden realizar utilizando varios entornos gráficos, pero al hacer todo manualmente, puede comprender mejor cómo funciona todo. Con la ayuda del comando ldd, puede ver qué bibliotecas usa nuestro programa:

Estas son las dos bibliotecas de carga, la libc estándar y la libm, que hemos incluido.

5. Automatización de montaje

Cuando nos planteamos la programación bajo Linux, es imposible no fijarse en el sistema de automatización del montaje de programas. El hecho es que cuando hay muchos archivos fuente de programas, no ingresará comandos manualmente para compilarlos. Puede grabarlos una vez y luego usarlos en todas partes. Hay una utilidad make y Makefiles para esto. Este archivo consta de destinos y tiene la siguiente sintaxis:

destino: dependencias
equipo

La dependencia del destino puede ser un archivo u otro destino, el destino principal es todo y el comando realiza las acciones de compilación necesarias. Por ejemplo, para nuestro programa, el Makefile podría verse así:

programa:programa.o
gcc -lm programa.o -o programa

programa.o: programa.c
gcc -c programa.c -o programa.o

Luego solo necesita ejecutar el comando make para iniciar la compilación, solo recuerde eliminar los archivos temporales anteriores y el programa construido:

El programa está listo de nuevo y puede ejecutarlo.

conclusiones

Creación programas linux muy interesante y emocionante. Verás esto por ti mismo cuando te familiarices un poco con este asunto. Es difícil cubrir todo en un artículo tan breve, pero hemos cubierto los conceptos básicos y deberían brindarle una base. En este artículo, cubrimos los conceptos básicos de la programación en Linux, si tiene alguna pregunta, ¡pregunte en los comentarios!

Curso de programación en C para Linux:

Las herramientas utilizadas tradicionalmente para escribir programas para sistemas operativos abiertos son las herramientas de desarrollo GNU. Hagamos un poco de contexto histórico. El Proyecto GNU fue fundado en 1984 por Richard Stallman. Su necesidad fue causada por el hecho de que en ese momento la cooperación entre programadores era difícil, ya que los dueños de los comerciales software creado numerosos obstáculos a dicha cooperación. El objetivo del proyecto GNU era crear un conjunto de software bajo una única licencia que no permitiera a nadie asignar derechos exclusivos sobre este software. Parte de este kit es el kit de herramientas para desarrolladores que usaremos, que debe incluirse con todas las distribuciones de Linux.

Una de estas herramientas es el compilador GCC. Este acrónimo originalmente significaba GNU C Compiler. Ahora significa - Colección de compiladores GNU.

Creemos el primer programa usando GCC. Por tradición, el primer programa simplemente imprimirá el saludo "¡Hola mundo!" - "¡Hola Mundo!".

Los archivos de código fuente para los programas que crearemos son archivos de texto sin formato y se pueden crear con cualquier editor de texto (p. ej., GEdit KWrite, Kate y los usuarios de Linux más tradicionales vi y emacs). Además de los editores de texto, existen entornos de desarrollo especializados con sus propios editores integrados. Una de esas herramientas es KDevelop. Curiosamente, tiene un editor integrado y una consola integrada ubicada justo debajo del editor. Entonces puede directamente en un programa, sin cambiar entre ventanas, y editar el código y dar comandos de consola.

Cree un directorio de saludo separado. Este será nuestro primer directorio de proyectos. en ella crea Archivo de texto hola.c con el siguiente texto:

#incluir

printf("¡Hola mundo!\n");

Luego, en la consola, vaya al directorio del proyecto. Marca un equipo

Ahora mira de cerca lo que pasó. Ha aparecido un nuevo archivo a.out en el directorio. Este es el archivo ejecutable. Vamos a lanzarlo. Escriba en la consola:

El programa debería iniciarse, es decir, debería aparecer el texto:

El compilador gcc asigna el nombre a.out a todos los ejecutables generados por defecto. Si desea nombrarlo de manera diferente, debe agregar el indicador -o y el nombre que desea asignarle al comando de compilación. Escribamos el siguiente comando:

gcc hola.c -o hola

Vemos que ha aparecido en el directorio un archivo ejecutable llamado hello. Vamos a lanzarlo.

Como puede ver, el resultado es exactamente el mismo archivo ejecutable, solo que con un nombre conveniente para nosotros.

El indicador -o es solo uno de los muchos indicadores del compilador gcc. Algunas otras banderas se discutirán más adelante. Puede usar el sistema de ayuda man para ver todas las banderas posibles. Escriba en la línea de comando:

Se le presentará un sistema de ayuda para este programa. Repase lo que significa cada bandera. Pronto conoceremos a algunos de ellos. Se sale del sistema de ayuda con la tecla q.

Por supuesto, notó que cuando ejecutamos un programa desde nuestro directorio de desarrollo, escribimos un punto y una barra antes del nombre del archivo. ¿Por qué estamos haciendo esto?

El caso es que si escribimos solo el nombre Archivo ejecutable, el sistema operativo lo buscará en los directorios /usr/bin y /usr/local/bin y, por supuesto, no lo encontrará. Los directorios /usr/bin y /usr/local/bin son los directorios de ubicación del sistema programas ejecutables. El primero de ellos está diseñado para albergar versiones estables de programas, normalmente incluidos en distribución de linux. El segundo es para programas instalados por el propio usuario (cuya estabilidad nadie garantiza). Se necesita un sistema de este tipo para separarlos entre sí. De forma predeterminada, los programas se instalan en el directorio /usr/local/bin cuando se compilan. Es altamente indeseable poner cualquier cosa adicional en /usr/bin o eliminar cualquier cosa de allí manualmente, porque esto puede provocar un bloqueo del sistema. Deben colocarse programas, de cuya estabilidad son responsables los desarrolladores de la distribución.

Para ejecutar un programa ubicado en otro lugar, debe especificar la ruta completa, así:

/home/dima/proyectos/hola/hola

O otra opción: escriba la ruta relativa al directorio actual en el que se encuentra actualmente en la consola. En este caso, un punto significa el directorio actual, dos puntos, el directorio principal. Por ejemplo, el comando ./hello ejecuta el programa hello ubicado en el directorio actual, el comando ../hello ejecuta el programa hello ubicado en el directorio principal, el comando ./projects/hello/hello ejecuta el programa en subdirectorios ubicados dentro el directorio actual.

Es posible agregar directorios adicionales a la lista de rutas del sistema a los programas. Para hacer esto, agregue una nueva ruta a la variable de sistema PATH. Pero no nos desviemos del tema principal por ahora. Variables de entorno es una conversación separada.

Ahora veamos lo que hace el programa gcc. Su trabajo incluye tres etapas: preprocesamiento, compilación y enlace (o linking).

El preprocesador incluye el contenido de todos los archivos de encabezado especificados en las directivas #include en el archivo principal. Los archivos de encabezado generalmente contienen declaraciones de funciones utilizadas en el programa, pero no definidas en el texto del programa. Sus definiciones están en otro lugar: ya sea en otros archivos fuente o en bibliotecas binarias.

La segunda etapa es la compilación. Consiste en convertir el texto del programa en lenguaje C/C++ en un conjunto de instrucciones de máquina. El resultado se almacena en un archivo de objeto. Por supuesto, en máquinas con diferentes arquitecturas de procesador, los binarios se obtienen en diferentes formatos, y en una máquina es imposible ejecutar un binario construido en otra máquina (a menos que tengan la misma arquitectura de procesador y los mismos sistemas operativos). Es por eso que los programas para sistemas tipo UNIX se distribuyen como códigos fuente: deben estar disponibles para todos los usuarios, independientemente de quién tenga qué procesador y qué sistema operativo.

La última etapa es el diseño. Consiste en vincular todos los archivos de objetos de un proyecto en uno, vincular las llamadas de función a sus definiciones y adjuntar archivos de biblioteca que contienen funciones que se llaman pero no están definidas en el proyecto. Como resultado, se forma un archivo ejecutable: nuestro objetivo final. Si se usa una función en un programa, pero el enlazador no encuentra el lugar donde se define esta función, emitirá un mensaje de error y se negará a crear un archivo ejecutable.

Ahora veamos cómo se ve todo en la práctica. Escribamos otro programa. Será la calculadora más primitiva capaz de sumar, restar, multiplicar y dividir. Cuando se inicie, le pedirá dos números a la vez para operar y luego le pedirá que ingrese el signo de la operación aritmética. Puede tener cuatro caracteres: "+", "-", "*", "/". Después de eso, el programa muestra el resultado y se detiene (nos devuelve a Sistema operativo, o mejor dicho, al intérprete de comandos, desde el cual llamamos al programa).

Vamos a crear para el proyecto. nueva carpeta kalkul, crearemos el archivo kalkul.c en él.

#incluir

printf("Primer numero: ");

scanf("%f",&num1);

printf("Segundo número: ");

scanf("%f",&num2);

printf(" Operador (+ - * /): ");

while ((op = getchar()) != EOF)

printf("%6.2f\n",num1 + numero2);

si no (op == "-")

printf("%6.2f\n",num1 - numero2);

si no (op == "*")

printf("%6.2f\n",num1 * numero2);

más si (op == "/")

printf("Error: division por cero!\n");

romper;

printf("%6.2f\n",num1 /num2);

Entonces, en primer lugar, como se dijo, se realiza el preprocesamiento. Para ver lo que se está haciendo en esta etapa, usaremos la opción -E. Esta opción detiene la ejecución del programa en la etapa de procesamiento por parte del preprocesador. El resultado es un archivo. código fuente con el contenido de los archivos de cabecera incluidos en él.

En nuestro caso, incluimos un archivo de encabezado - stdio.h - una colección características estándar de entrada y salida. Estas funciones envían el texto deseado a la consola y también leen las palabras que ingresamos desde la consola.

Introduzca el siguiente comando:

gcc -E kalkul.c -o kalkul.cpp

Llamamos al archivo resultante kalkul.cpp. Abrelo. Tenga en cuenta que es bastante largo. Esto se debe a que incluía todo el código en el archivo de encabezado stdio.h. Además, el preprocesador agregó aquí algunas etiquetas que le indican al compilador cómo comunicarse con las funciones declaradas. El texto principal de nuestro programa es visible solo en la parte inferior.

También puede ver qué otras funciones se declaran en el archivo de encabezado stdio.h. Si desea información sobre una función en particular, puede preguntar sobre ella en el hombre incorporado. Por ejemplo, si de repente quieres saber qué hace la misteriosa función fopen, puedes escribir:

También hay mucha información en la información del sistema de ayuda.

Puedes preguntarle a todos archivo de cabecera inmediatamente.

Veamos ahora el siguiente paso. Vamos a crear un archivo de objeto. Un archivo de objeto es una traducción "textual" de nuestro código de programa a lenguaje de máquina, pero sin vincular las funciones llamadas con sus definiciones. La opción -c se utiliza para generar un archivo de objeto.

El nombre del archivo resultante se puede omitir, ya que el compilador simplemente toma el nombre del archivo fuente y cambia la extensión .c a .o (puede especificar si queremos nombrarlo de otra manera).

Si estamos creando un archivo de objeto a partir de una fuente que ya ha sido procesada por el preprocesador (como la que obtuvimos arriba), entonces debemos indicar explícitamente que el archivo que se está compilando es un archivo de código fuente que ha sido procesado por el preprocesador. y tiene etiquetas de preprocesador. De lo contrario, se procesará como archivo ordinario C++, sin tener en cuenta las etiquetas del preprocesador, por lo que no se establecerá la relación con las funciones declaradas. La opción -x se usa para indicar explícitamente el idioma y el formato del archivo que se está procesando. El archivo C++ procesado por el preprocesador se indica mediante cpp-output.

gcc -x cpp-salida -c kalkul.cpp

Finalmente, el último paso es el diseño. Obtenemos el ejecutable del archivo objeto.

gcc kalkul.o -o kalkul

Puedes ejecutarlo.

Usted pregunta: “¿Por qué todo este alboroto con las etapas intermedias? ¿No sería mejor ejecutar gcc kalkul.c -o kalkul una vez?"

El hecho es que los programas reales rara vez constan de un solo archivo. Como regla general, hay varios archivos fuente y se combinan en un proyecto. Y en algunos casos excepcionales, el programa debe ensamblarse a partir de varias partes escritas en diferentes idiomas. En este caso, debe ejecutar compiladores de diferentes idiomas para que cada uno obtenga un archivo de objeto de su fuente y luego vincular estos archivos de objeto resultantes en un programa ejecutable.

Dmitry Panteleichev (dimanix2006 en rambler dot ru) - Introducción al compilador GCC

Nombre: Programación en C++ en Linux.

El libro "Programación en C++ en Linux" está dedicado al desarrollo de aplicaciones C++ en el entorno de desarrollo KDEvelop. El autor del libro da Descripción detallada interacciones de los componentes de la aplicación, cubre los aspectos básicos del trabajo con la utilidad Qt Designer y analiza los controles en los cuadros de diálogo y las clases para las que se crean. El libro enseña el concepto de Documento/Vista, creando elementos de interfaz de aplicación. También se abordan temas como guardar y restaurar diversa información que se muestra en la pantalla, desarrollar editores de texto, organizar la multitarea en aplicaciones basadas en procesos interactivos, trabajar con plantillas de clases y funciones. Como conclusión, el autor da aviso util para crear un sistema de ayuda para la aplicación desarrollada. El libro está destinado a programadores profesionales.

El libro está dedicado a la creación de aplicaciones escritas en C++ en el entorno de desarrollo de KDevelop. Es dada la descripción de los modos de interacción de los componentes de la aplicación. Se considera el trabajo con la utilidad Qt Designer y se describen los principales controles utilizados en los cuadros de diálogo, así como las clases creadas para trabajar con ellos. El lector es introducido al concepto de Documento/Vista y aprende a crear elementos de la interfaz de usuario de la aplicación. Además, los capítulos separados tratan los problemas de mostrar diversa información en la pantalla, guardarla y restaurarla desde un archivo, crear editores de texto, trabajar con plantillas de clases y funciones y organizar la multitarea en una aplicación basada en procesos interactivos. Concluye con pautas para crear el sistema de ayuda de la aplicación.

Contenido:
Introducción
¿Para quién es este libro?
estructura del libro
Las convenciones usadas en este libro
Requisitos de hardware y software
Capítulo 1 Interacción de los componentes de la aplicación
Señales y receptores
Enviando señales
Implementación del receptor
Implementación de conexión
Manejo de eventos
Trabajar con una ventana
Trabajar con enfoque de entrada
Operación del ratón
Operación del teclado
Implementación de arrastrar y soltar
Filtros de eventos
Eventos sintéticos
Secuencia de manejo de eventos
Conclusión
Capitulo 2 Cuadros de diálogo y controles básicos
Creación aplicación de diálogo
Crear un resguardo de solicitud
Creación de un ajuste preestablecido de cuadro de diálogo
Completar la aplicación de diálogo
Creación de cuadros de diálogo personalizados
Creación de un cuadro de diálogo con pestañas
Crear un asistente
Capítulo 3 Clases de control
clase de lista
Clases de regulador lineal e indicador lineal
Trabajar con fecha y hora
Capítulo 4 Clases de aplicación, documento y vista
Aplicación Qt multiventana
clase de documento
ver clase
Clase de aplicación
Aplicación KDE de ventanas múltiples
clase de documento
ver clase
Clase de aplicación
Capítulo 5 Creación de elementos de la interfaz de usuario
Interfaz de usuario bibliotecas qt
Hacer cambios en el menú
Trabajar con la barra de estado
Interfaz de usuario de la aplicación KDE
Hacer cambios en el menú
Personalización de la barra de herramientas
Trabajar con la barra de estado
Capítulo 6 Mostrar información en la pantalla
dibujar figuras
Trabajando con un cepillo
Redibujar ventana
Sincronización de objetos de vista
Salida de texto
Trabajar con mapas de bits
Mapas de bits dependientes del algoritmo
Mapas de bits independientes del dispositivo
Capítulo 1 Trabajar con archivos de documentos
Guardar y restaurar información en la aplicación
Personalización de cuadros de diálogo
Hacer cambios en el menú
Configuración del directorio de trabajo
Capítulo 8 Trabajar con documentos de texto
Construyendo un editor de texto simple
Construyendo un editor más complejo
Crear el editor de KDE
Capítulo 9 Plantillas y clases de colección
Plantillas
Concepto de plantilla
Plantillas de funciones
Plantillas de clase
Clases de colección
Tipos de clases de colección
arreglos
listas enlazadas
Mostrar mapas
Otras clases de colección
Capítulo 10 Implementación de tareas múltiples en una aplicación
Interacción de procesos
Crear un cliente para un servidor simple
Construyendo un servidor más complejo
crear un cliente
Algunas observaciones
Capítulo 11 Ayuda de la aplicación
Formularios de presentación de información de referencia
Cómo acceder al sistema de ayuda
Formas de presentar la información de fondo
Formas de presentación de la información.
Programación de ayuda contextual
Salida de pista
Mostrar información de ayuda en la barra de estado
Obtener información sobre un elemento específico
interfaz de usuario
Programación ayuda de comando
Formato de archivo de ayuda de comandos para aplicaciones Qt
Creación de una aplicación de demostración de Qt
Apéndice 1 Contenido del CD
Anexo 2 Recursos de Internet
Índice de materias

Descarga gratis libro electronico en un formato conveniente, mira y lee:
Descarga el libro Programación C++ en Linux - Nikolay Sekunov - fileskachat.com, descarga rápida y gratuita.

Descargar PDF
Puedes comprar este libro a continuación mejor precio con descuento con entrega en toda Rusia.

Quedó claro que el tema es muy relevante. Se tuvieron en cuenta algunos errores y preguntas, como resultado, se decidió realizar una segunda clase magistral. Añadido y corregido!

Clase magistral de programación en C bajo Linux. Estudiamos la API principal.

Este tutorial es para personas que quieren aprender la API * nix como OS, en particular bajo Linux. Aquí consideraremos las características del desarrollo bajo el sistema operativo Linux, que incluyen:

Familiarización con el proceso de creación de software y las especificaciones del compilador C de GCC

Desarrollo y uso de bibliotecas compartidas

Programas de depuración

Exploración de mecanismos de E/S de archivos de bajo nivel

Estudiar mecanismos para asegurar la multitarea y la comunicación entre procesos

Uso de archivos y sockets de red

Estudio y aplicación del mecanismo de las señales.

El estudio de procesos, subprocesos, su diferencia, el uso de subprocesos múltiples, el estudio de mecanismos de sincronización de subprocesos y sus problemas.

Creando demonios, aprendiendo la diferencia entre demonios y software de aplicación

Exploración de las funciones de E/S de la consola

Archivos mapeados en memoria y cómo usarlos

Esta clase magistral está destinada principalmente a desarrolladores de software, ingenieros, programadores y aficionados interesados en el dispositivo y las especificaciones del sistema operativo Linux.

Requisitos para los participantes de la clase magistral: Conocimiento del lenguaje C, al nivel del libro BV Kernighan, D. M. Ritchie "LENGUA C".

El costo de esta clase magistral será de 6.000 rublos.

La sede es la ciudad de Moscú, en las instalaciones de Hackspace Neuron.
Fechas: Aproximadamente del 4 de julio (lunes) al 7 de julio (jueves) de 10:00 a 17:00 horas con pausa para comer y pausas para té y café.

La transmisión en línea no está prevista.
Número de personas en el grupo: 8-10.

La grabación se realiza en correo electrónico [correo electrónico protegido] o comentar en esta publicación. Su nombre completo es requerido para el registro. (en su totalidad) y datos de contacto (número de teléfono y correo). Es conveniente describir el propósito de asistir a esta clase magistral, el nivel de formación y ocupación.

Programa detallado del curso:

Módulo 1: Introducción

Familiarización con las especificaciones de creación de software en GNU/Linux

Introducción a la consola editores de texto(vi,nano,mcedit)

Trabajando con el depurador gdb

Montaje de software manual y automático (Makefile)

Modelo Cliente-Interfaz-Servidor (CIS)

Edificio de biblioteca estática

Bibliotecas compartidas

Trabajar con variables de entorno

Módulo 2: E/S de bajo nivel y operaciones de archivo

Descripción general de los mecanismos de E/S de Linux (Ubuntu)

Descriptores de archivo

Llamadas al sistema: abrir, cerrar, escribir, leer y lseek

Tipos de archivo

Inodos y enlaces duros

Permisos de archivo

sistema de archivos proc

Dos formas de leer el contenido de un directorio

Archivos dispersos y detalles de su uso.

Bloqueo de áreas de un archivo

Módulo 3

Mecanismos de comunicación entre procesos de Linux (Ubuntu)

Tuberías sin nombre (tuberías)

Tuberías con nombre

Mensajes (cola de mensajes)

Memoria compartida

Semáforos

Módulo 4

Sockets en un espacio de nombres de archivo (sockets UNIX)

Par de enchufes

Tomas de red (sockets)

Módulo 5. Señales

Introducción a las señales

Cómo las señales difieren de otros mecanismos de comunicación entre procesos

Especificaciones del manejo de la señal

Módulo 6

Procesos de clonación - fork()

Reemplazo de un proceso en ejecución - exec()

Zombis (zombis): causas y formas de eliminarlos

Módulo 7

Hilos y procesos

Detalles de construcción aplicaciones multiproceso(multihilo)

Terminar un hilo antes de tiempo

Módulo 8 - Hilos (continuación)

Crear un controlador de terminación de subprocesos

Sincronizar primitivas

Atributos de transmisión

Módulo 9: Demonios (Servicios)

La diferencia entre un demonio y una utilidad de consola

Especificaciones de desarrollo de demonios

Creación de un daemon usando sockets de red

Módulo 10: E/S de consola

Especificaciones del desarrollo de aplicaciones de consola

Prevención de la redirección de salida

Gestión de terminales

Ocultar la contraseña del usuario durante la autenticación

Control de terminal con secuencias ESC

Módulo 11

Visualización de un archivo normal

Compartir un archivo

exhibiciones privadas

Otros usos de mmap

Módulo 12

Detalles del desarrollo de aplicaciones de 64 bits

Uso de la biblioteca ncurses