Чтобы быть действительно спорным:
Вы ничего не знаете!
или другими словами:
Я знаю, что ничего не знаю .
(это можно перефразировать во многих видах, но я думаю, что вы поняли это.)
При запуске с компьютеров / разработки, ИМХО, есть три этапа, через которые должен пройти каждый:
новичок: ничего не знает (это факт)
Промежуточный: думает, что он знает что-то / очень (/ все) (это тщеславие)
Профессионал: знает, что он ничего не знает (потому что как программисту чаще всего приходится работать над вещами, которых ты никогда не делал раньше). В этом нет ничего плохого: я люблю постоянно знакомиться с новыми вещами.
Я думаю, как программист, вы должны знать, как учиться - или лучше: учиться учиться (потому что помните: вы ничего не знаете!;)).
Я бы посоветовал купить другую книгу, потому что она, наверное, уже должна была вам сказать. Однако давайте перейдем к нему!
#include <stdio.h>
Эта часть сообщает "препроцессору" (часть компилятора, которая выполняет и подготавливает вещи к компиляции) принять содержимое файла "stdio.h" в некоторой специальной части свой компьютер и поместите его поверх исходного кода. Таким образом, компилятор может узнать о функции printf
ниже, о том, что она принимает в качестве аргументов и какое значение возвращает (возвращает после завершения).
void SayHello( void );
Эта часть объявляет функцию. Поместив определение туда, вы можете вызвать функцию перед написанием ее реализации. Этот "заголовок" функции сообщает компилятору, что будет функция, которая возвращает void (т.е. ничего. После ее завершения значение не возвращается. Например, вы не можете написать int a = SayHello ();
, потому что из SayHello ()
) ничего не возвращается. Это также не требует аргументов. Итак, вы не могли написать SayHello (34)
, потому что он принимает пустые аргументы, то есть их нет.
int main (int argc, const char * argv[]) {
Эта часть является началом «основной» функции. Функция main
- это то место, где ваш компьютер пытается запустить программу. Это отправная точка. Требуется два аргумента; количество аргументов ( int argc
), переданных в командной строке (на данный момент) и «массив» строк ( char *
) ». Массив содержит список однотипных данных. Таким образом, у вас может быть «массив» char *
. Если вы запустите свою программу так: ./ myProgram fish
, argv [1]
будет содержать массив символов ( char *
) «рыба». Не беспокойтесь об этой части слишком много, ваша книга объяснит это позже.
SayHello();
Эта часть вызывает функцию SayHello ()
. Заголовок SayHello
находится вверху, но программа вызывает фактическую реализацию функции ниже. SayHello
не принимает аргументов и не возвращает никакого значения ( void
). Компьютер временно перейдет к функции SayHello
. По завершении он возвращается к функции main
, на которой остановился. Мы вернемся к фактическому определению SayHello
позже.
return 0;
Функция main
возвращает целое число. Если все прошло нормально, вернет 0
; это означает, что программа завершилась корректно.
} // end of the function
void SayHello( void ) { // We already covered this part above
printf( "Hello, world!\n" );
}
Эта часть и есть реальная функция, которую мы сделали. Его единственная цель - вывести на консоль Hello, world!
. Для этого мы вызываем другую функцию , определенную в включенном нами файле stdio.h
. Его имя printf
. Он принимает различное количество строк (это будет рассмотрено намного позже в вашей книге) и выводится на консоль. Ваша книга, вероятно, очень скоро полностью покроет printf. На данный момент все, что он делает, это печатает одну строку (вы можете напечатать ее в таком формате: printf ("My Num is:% d", 34);
, который заменяет % d
с 34
. Однако пока просто помните, что он печатает строку. Итак, он печатает «Hello world!», За которым следует новая строка ( \ n
). printf
возвращает int
; но это только для целей восстановления после ошибок. После завершения printf
он возвращается к функции SayHello
, которая затем завершается и возвращается к main
, которая завершается и возвращает 0
.
Надеюсь, это все хорошо объясняет!
Что означает каждая строка?
// Include the Standard Input/Output Header to use its declared functions, ...
#include <stdio.h>
// Declare a function that takes no parameters and doesn't return a value.
void SayHello(void);
// Declare the main function which takes the program's character string
// arguments and returns an integer error code.
int main (int argc, const char * argv[]) {
// Call the above declared function with no parameters.
SayHello();
// Return the error code for OK to tell the OS everything went fine.
return 0;
}
// Define a function that takes no parameters and doesn't return a value.
void SayHello( void ) {
// Print a (constant) character string to the console that says Hello, world!
// and places the cursor on the next line.
printf( "Hello, world!\n" );
}
Ссылки
Как выполняется код?
Как это работает под капотом?
Вам, вероятно, не стоит вдаваться в подробности в этой статье. эта точка,
Надеюсь, следующий закомментированный код будет вам полезен:
#include <stdio.h> // Include the header file named `stdio.h`
void SayHello( void ); // Function named `SayHello` has been declared. It takes no (void) parametres.
int main (int argc, const char * argv[]) { // `main()` function is part of all C/C++ programs. It accepts command line arguments and returns an exit code. In this case, it returns an integer exit code.
SayHello(); // Call the function named `SayHello`
return 0; // Return from the `main()` function with the code 0 (success).
}
void SayHello( void ) { // Definition of function `SayHello`.
printf( "Hello, world!\n" ); // Use the `printf()` function in `stdio.h` header file to print the message.
}
Объяснение ...
void SayHello( void );
Эта строка является прототипом функции. Отсутствие кода намеренно. Это способ языка C сказать, что в какой-то момент позже будет функция, которая соответствует этой сигнатуре. C - это компилятор сверху вниз, поэтому он должен знать структуру функции, прежде чем сможет ее использовать.
int main (int argc, const char * argv[]) {
Это объявление основной функции. Аргументы командной строки для программы содержатся в параметре argv. Параметр argc отмечает количество аргументов, которые будут в параметре argv.
SayHello();
Вызывает функцию SayHello, не передавая параметров
return 0;
Завершает программу, возвращая 0, что свидетельствует об успешном выполнении программы.
void SayHello( void ) {
Это сигнатура определения функции. Он представляет собой начало пользовательской функции.
printf( "Hello, world!\n" );
Будет напечатан текст «Hello, world!»
#include <stdio.h>
Эта строка сообщает компилятору включить заголовочный файл stdio.h
, содержащий предварительные объявления программы для стандартных процедур ввода / вывода в C Стандартная библиотека .
void SayHello(void);
Это предварительное объявление или прототип функции для функции. Предварительное объявление - это способ сообщить компилятору, что позже функция будет определена, но вы хотите, чтобы он знал об этом сейчас, чтобы вы могли ее использовать. Эта конкретная функция называется SayHello
, она не принимает никаких параметров и не возвращает значения.
int main(int argc, const char *argv[]) {
Эта строка указывает, что определение функции с именем main
. Функция main
- это то место, где начинается выполнение программы. Эта функция принимает два параметра: argc
имеет тип int
, а argv
представляет собой массив const
из char *
. Параметры argc
и argv
представляют аргументы командной строки . Параметр argc
представляет количество аргументов командной строки, а argv
представляет фактические аргументы командной строки. Начало строки, int
, указывает, что функция main
возвращает значение типа int
. Эту строку отличает от предыдущей то, что она не заканчивается точкой с запятой (;
) и за ней следует открывающая скобка ( {
).
SayHello();
Эта строка кода вызывает функцию с именем SayHello
. Эта функция была объявлена ранее, но не определен.
return 0;
Эта строка кода заставляет функцию main
возвращать значение int
0
. Любой вызывающий main
получит возвращаемое значение 0
.
}
Эта строка кода сообщает компилятору, что мы находимся в конце определения main
].
void SayHello(void) {
Этой строкой кода вы теперь сообщаете компилятору, что далее следует определение функции SayHello
, которая была обещана ранее во второй строке.
printf("Hello, world!\n");
Эта строка кода вызывает стандарт функция ввода / вывода printf
, которая является частью стандартной библиотеки C . Функция printf
заставляет вывод отображаться на терминале; это довольно гибкая маршрутизация для форматирования и отображения текста на терминале. Вот, вы передаете один параметр, строку «Hello, world! \ n»
. Эта строка заканчивается escape-символом ( \ n
), который переводится в символ новой строки . Вызов printf
с параметром «Hello, world! \ N»
вызовет отображение
Hello, world!
на терминале.
}
Эта строка кода сообщает компилятору, что мы в конце определения SayHello
.
Короче говоря, строки кода говорят компилятору включить объявления методов в стандартные процедуры ввода / вывода стандартной библиотеки C (определения будет связан позже линкером ), объявляет функцию с именем SayHello
, определяет функцию main
, которая вызывается при выполнении программы, и определяет функцию с именем SayHello
. Функция main
вызывает функцию SayHello
и возвращает значение int
0
. Функция SayHello
заставляет строку
Hello, world!
отображаться на терминале.
Когда программа выполняется, выполнение начнется в функции main
, которая вызывает функцию SayHello
, который печатает на терминале строку «Hello, world!»
, за которой следует новая строка, а затем возвращается в main
, который возвращает значение int
0 звонящему.
main
вызывает функцию SayHello
и возвращает значение int
0
. Функция SayHello
заставляет строку
Hello, world!
отображаться на терминале.
Когда программа выполняется, выполнение начнется в функции main
, которая вызывает функцию SayHello
, который печатает на терминале строку «Hello, world!»
, за которой следует новая строка, а затем возвращается в main
, который возвращает значение int
0 звонящему.
main
вызывает функцию SayHello
и возвращает значение int
0
. Функция SayHello
заставляет строку
Hello, world!
отображаться на терминале.
Когда программа выполняется, выполнение начнется в функции main
, которая вызывает функцию SayHello
, который печатает на терминале строку «Hello, world!»
, за которой следует новая строка, а затем возвращается к main
, который возвращает значение int
0 звонящему.
#include <stdio.h>
Включить стандартную библиотеку ввода / вывода.
void SayHello( void );
Определите функцию с именем SayHello без возвращаемого значения и аргументов. Здесь не определено тело - оно будет определено позже.
int main (int argc, const char * argv[]) {
Определите другую функцию с именем main. Это точка входа в вашу программу. Он принимает 2 аргумента - целое число с именем argc (количество аргументов командной строки) и массив const char * с именем argv (аргументы командной строки). Запустите тело.
SayHello();
Вызовите метод SayHello, который мы определили ранее (запустите операторы внутри).
return 0;
Вернуть 0 (успех) обратно в операционную систему.
}
Завершить тело main ().
void SayHello( void ) {
Запустить тело функции SayHello, определенной ранее.
printf( "Hello, world!\n" );
Вывести «Hello, world!» к экрану. Функция printf взята из стандартной библиотеки ввода / вывода, которую мы включили ранее.
}
Завершите тело SayHello ().
Результатом этой программы будет:
Hello, World!
#include "stdio.h" <- вставляет другой файл c ++ в этот файл из неизвестной папки. Требует, чтобы программа была связана с некоторой библиотекой stdio.lib, которая обычно добавляется в компоновку программы по умолчанию.
MyType SayHello (недействительно); <- объявление функции, которая возвращает MyType-класс-экземпляр и не имеет аргументов
MyType SayHello (); <- то же самое
MyType SayHello (0); <- создание MyType-class-instance с переданным в конструктор класса целым числом 0.
void SayHello (); <- объявление функции, ничего не возвращающей (без операторов возврата внутри)
argc / argv <- дурацкие сокращения для "количества аргументов" и "вектора аргументов"
void SayHello () {...} < - код скомпилирован в двоичный файл программы, его может вызвать любой, кто знает объявление этой функции.
printf ("Hello, world! \ n"); <- переход к адресу памяти printf-функции, с одним строковым аргументом.
Заполнитель, чтобы следующая строка распознавалась как блок кода
#include <stdio.h>
Это говорит: «искать в пути поиска компилятора включаемые файлы для файла 'stdio.h' и вставлять содержимое здесь файлы. Обратите внимание, что это происходит еще до того, как компилятор даже увидит это.
void SayHello( void );
Это прототип функции. По сути, он говорит, что «будет определена функция, которая соответствует этой сигнатуре.
int main (int argc, const char * argv[]) {
SayHello();
Это вызывает вышеупомянутую функцию. Когда это достигается, выполнение переходит в тело функции и возвращается, когда функция завершается.
return 0;
Значение 0 возвращается в систему (что означает отсутствие ошибок по соглашению), и программа завершается. }
void SayHello( void ) {
printf( "Hello, world!\n" );
Это вызывает стандартную библиотечную функцию C printf и выводит заданную строку на стандартный вывод.
}