Руководство программиста на C++ — подробно
Прежде чем приступить к чтению, ознакомьтесь с полным Руководством разработчика C++, часть 1 ссылка.
Препроцессоры С++:
Это программа, которая обрабатывает ваш исходный код до того, как его увидит компилятор, удаляет комментарии из исходного файла и заменяет их одинарным пробелом, затем ищет директивы препроцессора и выполняет их.
Директивы препроцессора — это строки, начинающиеся с символа «#» (решётка или решетка), наиболее часто используемой директивой является директива «#include», когда компилятор видит эту строку, он заменяет эту строку файлом, на который он ссылается, и обрабатывает этот файл также, поэтому, когда компилятор видит исходный код, все комментарии удаляются, а все строки препроцессоров заменяются соответствующим файлом. Препроцессоры обычно используются для компиляции условного кода.
Например. если вы хотите скомпилировать небольшую часть кода, только если вы работаете в Windows и/или включаете специальные библиотеки Windows.
Важно. Препроцессоры не понимают код C++.
Основная функция:
Основная функция — это та, которая выполняется, пока мы запускаем нашу программу, это точка входа, весь код внутри main выполняется.
Основная функция без аргументов не требует дополнительной информации для запуска, в то время как основная функция с аргументами требует дополнительной информации для запуска.
#include <iostream>
using namespace std;
int main() {
cout << "Hello world";
return 0;
}
Выполнить: программа.exe
Эта вышеприведенная программа не нуждается в дополнительной информации для выполнения, в то время как существует другая версия main, которая принимает аргументы, как показано ниже.
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
cout << "Hello world" << argc;
return 0;
}
Выполнить: program.exe аргумент1 аргумент2
Эта программа нуждается в некоторой дополнительной информации для выполнения из командной строки, здесь argc означает количество аргументов, что означает количество аргументов или дополнительной информации, которую мы будем передавать через командную строку, второй аргумент, который мы передаем, это argv, что означает вектор аргумента, который содержит значения или строки, которые мы хотим передать в основную функцию, мы обсудим его позже.
Основная функция всегда должна возвращать 0,
Пространства имен:
Пространства имен пригодятся, когда мы используем две разные библиотеки и у нас есть конфликт имен между обеими библиотеками, например, компания x называет cout, а компания y также называет функцию cout, которую мы хотите использовать в нашей программе, поэтому программа не знает, какой cout использовать, поэтому пространство имен создает контейнеры и группирует объекты кода в качестве области пространства имен, компания x может создать пространство имен x и внутри этого пространства имен определите функцию cout, и компания y сделает то же самое, поэтому, если разработчику нужно использовать cout компании x, разработчик может использовать x::cout для доступа к функции cout объекта x и y::cout для использования cout объекта y. функция. Следовательно, он используется для уменьшения конфликтов имен.
'::' называется оператором разрешения области видимости.
Ранее мы использовали пространство имен для удаления std::cin, std::cout std::endl, как показано ниже.
#include <iostream>
using namespace std;
int main() {
cout << "Hello world";
return 0;
}
Однако по этой причине по-прежнему не оптимизировано использование пространства имен «std», используя пространство имен «std»; приносит всю кучу других имен, которые определены в этом пространстве имен, лучшая версия - включать только те, которые мы используем.
#include <iostream>
using std::cout;
int main() {
cout << "Hello world";
return 0;
}
Примечание. Оператор и Операнд: Оператор — это просто действие, которое нужно выполнить, например, сложение, вычитание, деление, умножение — все это операторы, тогда как операнды — это те, к которым применяется оператор. например, 2 + 3,поэтому 2 и 3 являются операндами, а+являютсяоператором сочетание оператора и операнда называется выражением.
Базовый ввод-вывод (ввод/вывод):
cin, cout, cerr, clog — наиболее распространенные базовые функции ввода и вывода.
1. cout и ‹‹:
‹‹ — оператор вставки, он вставляет значение операнда слева от него, например, для данных cout‹‹; поэтому здесь данные являются операндом, а '‹‹' используется для вставки значения данных в левой части, чтобы добавить разрывы строк, нам нужно указать разрыв строки, используя endl или '\n' (end линейный символ)
Примечание. ‘\n’ в языке программирования используется для разрыва строки.
Если мы используем манипулятор endl, поток входного буфера очищается,
Когда пользователь вводит несколько значений, программа считывает их как поток ввода и присваивает их переменным, если используется endl, этот поток ввода сбрасывается. Мы увидим в разделе обработки файлов позже.
Мы можем связать несколько данных с помощью ‹‹, как, например, ниже,
cout << “the value of radius and area is: ” << radius << area;
Здесь радиус и площадь — переменные, объявленные в программе.
2. цин и ››:
›› называется оператором извлечения, он извлекает входные данные из входного потока cin, которые добавляются пользователем с клавиатуры, и сохраняет в переменной справа. Оператор извлечения считывает целое число, если переменная справа имеет значение тип integer, он будет читать float для типа float, последовательность символов для переменной строкового типа.
Он также может быть объединен в цепочку, как cout и ‹‹,символы читаются только тогда, когда пользователь закончил ввод значения и нажал клавишу ввода, когда два значения были извлечены с использованием цепочки, как показано ниже.
cin >> data1 >> data2;
Пробелы, вкладки новой строки, считаются окончанием значения, которое было извлечено, поэтому, если пользователь вводит данные.
2 3
Пробел здесь заканчивается, читая значение data1, поэтому 2 сохраняется в data1, а data2 будет содержать значение 3, вышеприведенное называется входной поток.
Чтение cin завершается ошибкой, когда тип данных переменной и тип пользовательского ввода отличаются, поэтому данные будут иметь неопределенное значение.
Допустим, мы хотим прочитать два значения: одно целое и одно двойное (десятичное значение),
cin >> intValue >> doubleValue;
Итак, если пользователь вводит 10.5 с терминала:
10.5
«intValue» будет содержать 10 как целочисленное значение, а 0,5 будет храниться в переменной «doubleValue».
Локальные и глобальные переменные:
Переменные, объявленные внутри любой функции, являются локальными для этой функции, к которым нельзя получить доступ или использовать вне этой функции, глобальные переменные — это переменные, к которым можно получить доступ где угодно или внутри любой функции.
#include <iostream>
int global_age = 10; // global variable
int main () { // main function starts here
int age {18}; // local variable to main function
cout << age << " years old";
return 0;
} // main function ends here
age = 10; // since it is local to main function it cannot be
// accessed here and it will give compile time error
Примечание. Элемент управления сначала проверяет функцию, если age присутствует или нет, если он присутствует, то использует его, но если он отсутствует, он смотрит на глобальный уровень и проверьте, присутствует ли возраст, если он присутствует, он будет использовать его, а если нет, то выдаст ошибку.
Переменные и их типы:
Ранее мы видели введение в типы переменных, в этом разделе подробно рассказывается о том, почему типы данных важны.
Примитивные типы данных — это типы, которые непосредственно реализованы в C++, некоторые из часто используемых примитивных типов данных — это int long float double bool char и т. д. Мы увидим char, int, типы с плавающей запятой и логические типы, для разработчика C++ важно знать, какой объем памяти должен быть предоставлен переменной для хранения определенного значения, размер и точность зависят от компилятора, поэтому мы используем #include ‹climits›, который содержит все необходимое.
Поскольку мы знаем, что компьютеры хранят данные в 0 и 1, следовательно, размеры выражаются в битах, чем больше битов мы выделяем, тем больше уникальных значений может быть представлено и тем больше памяти для представления этой памяти.
Формула, чтобы получить, сколько различных значений может быть представлено, равна степени n 2, где n — количество битов. Таким образом, 8 битов могут представлять 2⁸ = 256 различных значений.
Тип символьных данных:
Он используется для представления символов, таких как «A», «a», «B», «b» и т. д., тип данных char реализован в 8 бит, что означает, что он может представлять 256 символов, что достаточно для представления всех алфавитов, однако многие языки смесь нескольких отдельных символов и символов, Unicode является общим стандартом для представления нескольких наборов символов любого языка.
Пример:
#include <iostream>
int main () {
char initial {'K'};
cout << "My initial is: " << initial;
return 0;
}
Вывод:моиiначальные значения: K
Примечание. Здесь мы использовали {} после инициализации, которая используется для инициализации значения. поэтому переменная «initial» будет содержать значение как символ «K».
Целочисленные типы данных:
Он имеет знаковые и беззнаковые целочисленные типы данных, следующие типы и используемый объем памяти.
Если нам нужно объявить целое число со знаком, нам не нужно писать ключевое слово 'signed', поскольку целые числа по умолчанию являются значениями со знаком. Длинное целое число со знаком попадает в диапазон [-2147483648 до 2147483647], тогда как длинное целое число без знака попадает в диапазон 0 до 4294967295, это означает, что значение больше 2147483647 не может быть сохранено в переменной long int, нам понадобится long long int для его обработки, аналогично, значения больше 4294967295 не будут храниться в переменных unsigned long int, нам понадобится unsigned long long внутр.
Пример 1:
#include <iostream>
int main () {
unsigned short int exam_score {22};
cout << "My exam marks are: " << exam_score;
return 0;
}
Вывод: Мои экзаменационные оценки: 22.
Пример 2:
#include <iostream>
int main () {
int countries_count {65};
cout << "Countries count is: " << countries_count;
return 0;
}
Вывод:Количество стран: 65.
Пример 3:
#include <iostream>
int main () {
long int people_in_india {13800000};
cout << "People in India is: " << people_in_india;
return 0;
}
Вывод:Население Индии: 1 3800 000
Пример 4:
#include <iostream>
int main () {
long int people_on_earth {7'60'000'000};
cout << "People in earth is: " << people_on_earth;
return 0;
}
Это приведет к ошибке в виде сужающего преобразования, и это потому, что мы пытаемся вписать большие числа в long int, у которого нет места для хранения.
Примечание. Эта ошибка будет отображаться только при использовании инициализации списка, если мы используем обычную инициализацию, например long int people_on_earth = 7'60'000'000; тогда переменная people_on_earth получит какое-то ерундовое случайное значение.
Примечание. Здесь, в этом примере, мы использовали тики как 7'60'000'000, поэтому стандарт C++ 14 позволяет нам использовать тики для целей чтения, если он не компилируется, ваш компилятор не C++ 14
Фиксированный код:
#include <iostream>
int main () {
long long int people_on_earth {7'60'000'000}; // added long long
cout << "People on Earth: " << people_on_earth;
return 0;
}
Вывод:Население Земли: 7 600 000 000.
Плавающий Тип данных:
Эти типы данных используются для представления нецелочисленных значений, таких как действительные числа, например, 0,1, 2,4, 5,5 или пи, некоторые числа имеют бесконечное количество цифр после запятой, а компьютеры имеют конечное хранилище, пи является прекрасным примером этого, в таких случаях, когда компьютер хранит приблизительные значения таких чисел, числа с плавающей запятой хранятся внутри как числа со знаком.
В приведенной выше таблице показаны тип и соответствующий диапазон с десятичными цифрами, которые поддерживаются для соответствующих типов данных.
Пример 1:
#include <iostream>
int main () {
float car_payment {204.1};
cout << "Your car payment is: " << car_payment;
return 0;
}
Вывод:ваш платеж за автомобиль: 204.1.
Пример 2:
#include <iostream>
int main () {
double pi {3.14159};
cout << "Pi is: " << pi;
return 0;
}
Вывод:Pi: 3,14159
Пример 3:
#include <iostream>
int main () {
long double very_large_no {2.7e120};
cout << "very large number is: " << very_large_no;
return 0;
}
Вывод:очень большое число: 2,7e120.
Логический Тип данных:
Логический тип данных используется для представления истинного или ложного значения, он занимает 8 бит, в С++ значение 0 считается ложным значением, а любое ненулевое значение считается истинным значением, логическое значение также содержит ключевые слова true и false в качестве значений, логическое значение значения очень важны при программировании, например, для isActive, 'gameOver'.
#include <iostream>
int main () {
bool game_over {false};
cout << "Is Game Over? : " << game_over;
return 0;
}
Вывод: Игра окончена? : 0.
Здесь вывод должен быть ложным, но в С++ значение 0 означает ложное.
Пример переполнения:
#include <iostream>
int main () {
short int value1 {30000};
short int value2 {1000};
short product {value1 * value2}; // must use long int product
cout << "Product of value1 and value 2 is: " << product;
return 0;
}
Выходные данные:произведение value1 и value 2 равно:-2763.
Это значение неверно, так как произведение значение1 и значение2 дает число, которое не подходит для коротких интервалов, следовательно, мы должны использовать произведение длинного целого числа. >
оператор sizeof:
Простой способ определить размер типа данных с помощью оператора sizeof. Например, для 'sizeof(int)', 'sizeof(double)', 'sizeof(some_variable)' и т.д., оператор 'sizeof' получает информацию из двух заголовочных файлов 'climits' и 'cfloats', эти файлы также предоставляют кучу полезных константы, которые можно использовать для определения точности наших типов данных, например, INT_MAX сообщает нам максимальное целочисленное значение, которое мы можем хранить в типе данных int на конкретной машине.
#include <iostream>
#include <climits>
#include <cfloat>
using std::cout;
int main () {
cout << "sizeof information" << endl << "================"<< endl;
cout << "char: "<< sizeof(char) << endl;
cout << "int: "<< sizeof(int) << endl;
cout << "unsigned int: "<< sizeof(unsigned int) << endl;
cout << "short: "<< sizeof(short) << endl;
cout << "long: "<< sizeof(long) << endl;
cout << "long long: "<< sizeof(long long) << endl;
cout << "float: "<< sizeof(float) << endl;
cout << "double: "<< sizeof(double) << endl;
cout << "long double: "<< sizeof(long double) << endl;
cout << "======================="<< endl<<"Minimum values:"<<endl;
cout << "char: "<<CHAR_MIN<< endl;
cout << "int: " << INT_MIN << endl;
cout << "short: " << SHRT_MIN << endl;
cout << "long: " << LONG_MIN << endl;
cout << "long long: " << LLONG_MIN << endl;
cout << "======================"<< endl <<"Maximum values:"<<endl;
cout << "char: "<<CHAR_MAX << endl;
cout << "int: " << INT_MAX << endl;
cout << "short: " << SHRT_MAX << endl;
cout << "long: " << LONG_MAX << endl;
cout << "long long: " << LLONG_MAX << endl;
int age {21};
double wage {22.54};
cout << "Size of age is: " << sizeof age << endl;
cout << "Wage is: "<< sizeof(wage) << endl; //both are same
return 0;
}
Вывод: вывод может отличаться на разных машинах
sizeof information ================== char: 1 int: 4 unsigned int: 4 short: 2 long: 4 long long: 8 float: 4 double: 8 long double: 12 ================== Minimum values char: -128 int: -2147483648 short: -32768 long: -2147483648 long long: -9223372036854775808 ================== Maximum values char: 128 int: 2147483648 short: 32768 long: 2147483648 long long: 9223372036854775808 Age is: 4 wage is: 8
Каждое значение выше единицы является байтом, могут использоваться как «sizeof», так и «sizeof (возраст)».
Константы в С++:
Константы — это переменные, которым при присвоении значения нельзя изменить. Существует много типов констант:
Примечание. Константные выражения (ключевое слово constexpr), перечисляемые константы (ключевое слово enum) будут рассмотрены в последующих главах.
1. Литеральные константы:
Буквенные константы - это простые константы, например. pi = 3,14, days _in_week = 7 и т. д. и т. д.
Мы можем указать тип литеральных констант, как в случае с целочисленными литеральными константами, мы добавляем суффиксы к целочисленным литералам, чтобы указать другой тип, например, U и L представляют, беззнаковые и длинные, соответственно, которые могут быть строчными или прописными, например, 12U, 12L, 12LL и т. д.
Для суффиксов с плавающей запятой мы можем использовать F и L для float и long double соответственно, например, 12.1, 12.1F 12.2L.
У нас также есть константы символьных литералов,
\n для новой строки,
\t для новой вкладки,
\r для возврата,
\b для возврата,
\’ одиночная кавычка,
\» двойная кавычка,
\\ обратная косая черта.
Они используются в строковых литералах, например
cout << “Hello \t there \n my friend \n”;
Это выведет:
Hello there my friend
2. Объявленные константы (ключевое слово const):
Наиболее часто используемое объявление констант — это объявление констант с использованием ключевого слова const, например, const float pi {3.145926}; нам всегда нужно инициализировать объявленные константы их начальным значением, иначе компилятор выдаст вам ошибку.
3. Определенные константы (ключевое слово #define):
Никогда не используйте определенные константы в современной разработке на С++, в старых разработках программ на С++ использовались определенные константы. Компилятор не понимает определенные константы и никогда не выдает ошибку, так как он предварительно обрабатывается.
Синтаксис:
#define pi 3.145926
Давайте использовать это,
Постановка задачи. Представьте, что у вас есть служба ремонта велосипедов, вы берете 30 долларов США за один велосипед + налог в размере 6%, расчеты действительны в течение 30 дней.
Подскажите номер велосипеда, который пользователь отремонтирует, и предоставьте свою оценку, например:
Bike repair service: Number of Bikes: 2 Price per Bike: $30 cost: $60 tax: $3.6
Код без констант:
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main () {
cout << "Welcome to Bike repair garage" << endl;
cout << "\nHow many bikes would you like to repair?" << endl;
int bike_count {0};
cin >> bike_count;
cout << "\nEstimate for Bike repairing:" << endl;
cout << "\n Number of Bikes: " << bike_count;
cout << "\n Price per Bike: $<< 30 << endl;
cout << "Cost: $" << 30 * bike_count << endl;
cout << "Tax: $" << 30 * bike_count * 0.06 << endl;
// 0.06
// because of 6% i.e. 6/100 ~ 0.06
cout << "====================================" << endl;
cout << "Total estimate:"<<(30* bike_count)+(30*bike_count *0.06)<<endl;
cout << "This estimate is valid for "<< 30<<"days"<<endl;
cout << endl;
}
Код с использованием констант:
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main () {
cout << "Welcome to Bike repair garage" << endl;
cout << "\nHow many bikes would you like to repair?" << endl;
int bike_count {0};
cin >> bike_count;
const double price_per_bike {30.0};
const double sales_tax {0.06};
const int expiry_duration {30}; // days
cout << "\nEstimate for Bike repairing:" << endl;
cout << "\n Number of Bikes: " << bike_count;
cout << "\n Price per Bike: $<< price_per_bike << endl;
cout << "Cost: $" << price_per_bike * bike_count << endl;
cout << "Tax: $" << price_per_bike * bike_count * sales_tax <<
endl;
cout << "===============================" << endl;
cout << "Total estimate:"<<(price_per_bike* bike_count)+
(price_per_bike*bike_count *sales_tax)<<endl;
cout << "This estimate is valid for "<< expiry_duration<<"days"
<<endl;
cout << endl;
}
Это называется рефакторингом, то есть изменением кода без изменения его поведения.
Третью часть этой серии можно найти, нажав здесь.
Пожалуйста, поделитесь этим с как можно большим количеством людей.
TLDR;
Другие блоги, связанные с технологиями, см. на странице:
khizaruddins.medium.com
Следите за мной в twitter и instagram
Купи мне Кофе.
