Как присвоить значение переменной в с

Для сокращённой записи выражений в языке программирования С++ есть специальные операции, которые называются операциями присваивания. Рассмотрим фрагмент кода, с использованием операции присваивания.

int value = 256; value = value + 256; // обычное выражение с использованием двух операций: = и + value += 256; // сокращённое эквивалентное выражение с использованием операции присваивания

В строке 2 переменной value присваивается значение 512, полученное в результате суммы значения содержащегося в переменной value с числом 256. В строке 3 выражение выполняет аналогичную операцию, что и в строке 2, но выражение записано в упрощённом виде. В этом выражении присутствует операция присваивания со знаком плюс += . Таким образом, операция += суммирует значение переменной value co значением, которое находится правее: 256, и присваивает результат суммы этой же переменной. Как видно из примера оператор в строке 3 короче оператора в строке 2, хоть и выполняет аналогичную операцию. Так что, если некоторую переменную нужно изменить, то рекомендуется использовать операции присваивания.

В С++ существует пять операций присваивания, не считая основную операцию присваивания: = .

  1. += операция присваивания-сложения;
  2. -= операция присваивания-вычитания;
  3. *= операция присваивания-умножения;
  4. /= операция присваивания-деления;
  5. %= операция присваивания-остатка от деления;

Договоримся называть операции присваивания через дефис, чтобы было понятно о какой именно операции идёт речь. В таблице 1 наглядно показаны примеры использования операторов присваивания в языке программирования С++.

Операции присваивания в С++Операция Обозначение Пример Экв.пример Пояснение
операция присваивания-сложения+=var += 16var = var + 16Прибавляем к значению переменной var число 16, результат суммирования сохраняется в переменной var
операция присваивания-вычитания-=var -= 16var = var — 16Вычитаем из переменной var число 16, результат вычитания сохраняется в переменной var
операция присваивания-умножения*=var *= 16var = var * 16Умножаем значение переменной var в 16 раз, результат умножения присваивается переменной var
операция присваивания-деления/=var /= 16var = var / 16Делим значение переменной var на 16, результат деления присваивается переменной var
операция присваивания-остатка от деления%=var %= 16var = var % 16Находим остаток от деления и сохраняем его в переменной var

Разработаем программу, которая будет использовать операции присваивания.

// assignment.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include using namespace std; int main(int argc, char* argv[]) < int value = 256; cout > » > » > » > »

Для начала в строке 9 была объявлена переменная value , и инициализирована значением 256. В строках 11, 13, 15, 17, прописаны операции присваивания – сложения, вычитания, умножения и деления соответственно. После выполнения каждой операции присваивания оператор cout печатает результат. Результат работы программы (см. Рисунок 1).

ЧТО ТАКОЕ ПЕРЕМЕННАЯ В C# | ОБЪЯВЛЕНИЕ И ИНИЦИАЛИЗАЦИЯ ПЕРЕМЕННЫХ | ПРИСВОЕНИЕ ЗНАЧЕНИЙ | C# Урок #4


CppStudio.com
value = 256 value += 256; >> 512 value -= 256; >> 256 value *= 2; >> 512 value /= 8; >> 64 Для продолжения нажмите любую клавишу . . .

Рисунок 1 – Операции присваивания в С++

На рисунке 1 наглядно показаны примеры выполнения операций присваивания, а также показан результат выполнения соответствующей операции присваивания.

Оператор присваивания. Запись значения в переменную на Си

Как Вы помните, переменные нужны чтобы хранить в них какие-то данные. Разберёмся как использовать переменные по их прямому назначению. Основной вопрос такой: «Как сохранить значение в переменной». Или вспоминая аналогию с коробкой «Как положить что-то в коробку?»

Ответ прост. Для этого существует специальный оператор, который называется оператором присваивания и обозначается символом равно » code-left»>

Листинг 1. Присваивание значения переменной

int z; // объявляем переменную целого типа с именем z z = 5; // заносим в переменную число 5 double pi = 3.1415926; // создаём переменную и сразу присваиваем ей значение

В примере выше показаны два способа присвоить значение переменной. В первом случае мы сначала создаём переменную, а потом записываем в неё значение, а во втором случае мы сразу создаём переменную и присваиваем ей значение.

Второй вариант записи короче, но делает в то же самое, что и первый. Берёт значение, которое записано справа от знака равно, и сохраняет его в переменную, которая записана слева от от него.

Не забывайте ставить после очередной команды точку с запятой.

Есть несколько важных моментов на которых надо отдельно заострить внимание:

  • в некоторых языках программирования, после того как вы создали переменную, в ней сразу же хранится значение нуль. В языке Си это не так. Пока переменной не присвоено какое-нибудь значение, в ней будет храниться «мусор». Как этот мусор выглядит мы посмотрим на следующем уроке.
  • справа от знака равно НЕ обязательно должно быть записано какое-то конкретное число, там может быть записано арифметическое выражение или имя переменной.

int n; n = 1+2; // В переменную n записываем значение 3
Когда переменной присваивается значение, то то, что хранилось в ней до этого удаляется.
int n=10; // Создаём переменную и записываем в неё 10 n = 5; // Теперь в переменной записано значение 5, а значение 10 удалено.

Обратите внимание, новое значение не добавляется к старому, а полностью заменяет его. Я как-то говорил, что переменные похожи на коробки, но только на первый взгляд. Теперь мы видим, что наша аналогия с коробкой не совсем точная. Если бы в коробке лежало десять шариков, и мы бы туда положили ещё пять, то их стало бы 15. В выражении справа от знака равенства могут использоваться другие переменные, которые объявлены ранее. Вместо них в выражение подставляются значения, которые в них хранятся в данный момент.

int n=10, x=0; // можно инициализировать сразу несколько переменных n = 5; // теперь n равно 5 x = n — 3; // x будет равно 2 (5-3)

При вычислении выражения n — 3, n равняется 5. Это потому, что исходное значение 10, заданное при инициализации, мы в программе изменяли. А при вычислениях используется текущее значение переменной. В выражении справа от знака равенства может быть использована сама переменная.

int n=10; n = n + 5; // n будет равно 15 (10+5)

Кажется, что это какой-то порочный круг, но на самом деле проблем здесь не возникнет. Т.к. сначала вычисляется выражение справа, а только потом происходит присваивание. По аналогии с предыдущим примером при вычислении значения справа от знака равно вместо переменной n будет подставлено её текущее значение, т.е. 10. Потом будет произведено сложение и присваивание. Ещё один поучительный пример.

int x=5, y=0, z; y = x + z; // что будет записано в переменной y?

Если Вы подумали что 5, то это неправильно. Никто не знает, что в ней будет записано. Т.к. неизвестно, что было записано в переменной z. Ещё раз напоминаю, что если переменной не присвоено никакое значение, в ней хранится не нуль, а неизвестно что. Выражение справа от знака равно может быть достаточно сложным, оно не обязательно будет состоять из одного действия.

int a = 2, b=9, c=4, D; D = b*b — 4*a*c; // D будет равно 49 (9*9 — 4*2*4)

Теперь ещё один важный момент, который надо понимать. Когда я рассказывал о типах данных, я говорил, что в переменной можно хранить значения только того же типа, что и тип переменной. Например, в переменную целого типа нельзя положить вещественное число. Этот принцип применяется и с выражениями. Чтобы программа работала корректно, необходимо, чтобы тип выражения или переменной справа от знака присваивания совпадал с типом переменной. Посмотрим несколько примеров.

int n, a = 2; double x, pi = 3.14; char s = ‘k’; // сохраняем в s символ k. Сам символ нужно написать в одинарных кавычках. s = pi; // неправильно. В коробку для символов пытаемся положить вещественное число n = a*pi; // неправильно. В коробку для целых числе пытаемся положить 6.28 (2*3.14) a = x; // неправильно. В целочисленную переменную пытаемся сохранить вещественное число x = 2+a; // ДОПУСТИМО. x будет равно 4.0

Внимание на последнюю строчку! Хотя справа выражение целого типа, а слева вещественная переменная, данная команда всё равно будет работать так, как надо. Это из-за того, что все целые числа можно записать как вещественные, у которых дробная часть равна нулю. Подобная штука называется неявное приведение (преобразование) типов . С этой возможностью надо быть очень осторожным, т.к. компилятор не отслеживает такие ошибки. Другими словами программа будет скомпилирована, но работать будет неправильно. Мы ещё вернёмся к этому в следующем уроке, когда научимся выводить значение переменных на экран компьютера. Сохрани в закладки или поддержи проект.

Синтаксис оператора присваивания

В программировании оператор присваивания используется для присваивания значения переменной. Синтаксис оператора присваивания в языке C очень простой, это просто знак равенства (=).

Слева от знака равенства должна быть переменная, которой мы хотим присвоить значение, а справа — значение, которое мы хотим присвоить. Например:

  • int x = 10; — это присваивание целочисленной переменной x значения 10.
  • float y = 2.5f; — это присваивание переменной типа float значения 2.5.
  • char z = ‘a’; — это присваивание переменной типа char значения ‘a’.

Также можно присваивать значение переменной, используя её текущее значение. Для этого используется оператор присваивания с сокращением, например:

  • x += 5; — это эквивалентно записи x = x + 5;
  • y -= 1.3f; — это эквивалентно записи y = y — 1.3f;

Оператор присваивания можно использовать в выражениях, например:

  • a = b = c = 10; — это эквивалентно последовательному присваиванию c = 10;, b = c;, a = b;
  • sum += num1 + num2; — это эквивалентно записи sum = sum + num1 + num2;

Использование оператора присваивания с числовыми значениями

В языке программирования C, присваивание значения переменной осуществляется с помощью оператора присваивания “=”. Для присваивания числового значения переменной, достаточно написать имя переменной, затем знак “=”, и необходимое числовое значение.

Например, для присваивания переменной “a” числового значения 10, необходимо написать следующую строку кода:

a = 10;

Таким образом, переменная “a” будет иметь значение равное 10.

Также, можно использовать арифметические операции вместе с оператором присваивания. Например, для увеличения значения переменной “a” на 5, можно написать следующую строку кода:

a += 5;

Таким образом, переменной “a” будет присвоено значение, равное текущему значению “a” плюс 5. В данном случае, значение переменной “a” увеличится до 15.

  1. Для уменьшения значения переменной на заданную величину, необходимо вместо “+=” использовать оператор “-=” (например, a -= 5 уменьшит значение переменной “a” на 5).
  2. Для умножения значения переменной на заданную величину, необходимо использовать оператор “*=” (например, a *= 2 умножит значение переменной “a” на 2).
  3. Для деления значения переменной на заданную величину, необходимо использовать оператор “/=” (например, a /= 2 разделит значение переменной “a” на 2).

Таким образом, использование оператора присваивания с числовыми значениями в языке программирования C позволяет управлять значениями переменных и производить различные арифметические операции над ними.

Вещественные литералы

Помимо целочисленных в программе можно прописывать и вещественные литералы. Определять их можно следующими способами:

double d1, d2, d3, d4; d1 = 10.0; d2 = -7.; d3 = 1e2; d4 = 5e-3;

В первых двух случаях используется символ точки. Причем, обратите внимание, несмотря на то, что числа 10.0 и -7.0 с математической точки зрения соответствуют целым числам 10 и -7, на уровне программы они будут вещественными и иметь тип double. Все вещественные литералы компилятор языка Си по умолчанию представляет этим типом данных. Соответственно, математические операции с числами 10.0 и -7.0 будут выполняться несколько иначе, чем с аналогичными целыми числами. Это следует иметь в виду. Последние два варианта – запись числа в экспоненциальной форме: <число>e Например, запись: Такую форму удобно использовать в научных расчетах, когда используются или очень маленькие или очень большие числа. В любом случае экспоненциальная форма переводится в вещественное число типа double, даже если оно математически является целым, а не дробным. При желании мы можем явно указать компилятору переводить вещественный литерал в тип float. Для этого после числа следует прописать суффикс f, например, так:

d1 = 10.0f;

В такой записи вещественное число 10.0 будет представляться типом float, а не double. Это бывает полезно, когда используется переменная типа float и ей правильно было бы присвоить значение того же типа:

float var_f; var_f = 10.0f;

Тогда компилятор не выдаст предупреждение (warning) о возможной потере данных в момент присваивания значения переменной var_f.

Операция sizeof

В заключение этого занятия отмечу довольно распространенную операцию sizeof языка Си. Она возвращает число байт, занимаемых в памяти переменной или, отведенных под тип данных. Синтаксис этой операции следующий: sizeof(<тип | имя переменной>); sizeof ; Обратите внимание, во втором случае мы можем записать ключевое слово sizeof без круглых скобок, но тогда эта операция применяется только к переменным, но не к типам. Чтобы не запоминать эти тонкости, обычно sizeof записывают с круглыми скобками и указывают либо тип данных, либо имя переменных. Например:

int size_float = sizeof(float); int size_var_f = sizeof(var_f);
На выходе получаем число байт, которое занимает тип float и переменная var_f. Соответственно:
int size_ch = sizeof(char);
всегда равно единице.

C Урок 16. Операторы присваивания

Изучив в течение 15 предыдущих уроков очень многое из языка C, а также попрактиковавшись изрядно с данным языком в наших учебных проектах, мы поняли, что для того, чтобы переменная получила новое значение, его надо ей как-то присвоить. Для этого мы использовали оператор присваивания = .

Оказывается, что есть ещё некоторые операторы, представляющие из себя вышеуказанный оператор присваивания в комбинации с другими операторами, также являющиеся операторами присваивания. Также существует возможность использовать операции присваивания в выражениях. Поэтому было принято решение посвятить этому отдельный урок. Думаю, что он будет небольшим, но весьма нужным.

Начнём с обычной базовой операции присваивания, которая обозначается вот так

Данный оператор является бинарным и операция с помощью него происходит над двумя операндами, которые находятся справа и слева оператора. Справа обычно выражение (может быть константа, которая, в принципе, тоже является выражением), а слева — переменная. При этом результат выражения, которое находится справа, становится значением этой переменной. Причём тип данных выражения справа не всегда может совпадать с типом переменной, при этом сначала происходит приведение типа к типу переменной. Об этом мы уже знаем.

Приведём несколько примеров присваивания

x = 15 ;

y = x + 1 ;

z = x * (y -5 );

Мы можем применить несколько операций присваивания одновременно

z = y = x = 5 ;

Порядок выполнения нескольких операций присваивания в данном случае — справа налево. То есть, сначала результат выражения присваивается переменной x, затем значение переменной x присваивается переменной y а уж затем значение переменной y — переменной z.

Выражения справа от оператора присваивания могут быть также и необычными, представлять собой, например, какие-нибудь условия

Так как результат условий бывает лишь двух видов — ИСТИНА или ЛОЖЬ, что в математическом выражении — 1 или 0, то соответствующий результат и присвоится переменной, стоящей справа. Если x будет меньше 10, то присвоится 1, если нет — то 0.

Также присваивание может происходить в самом выражении, например выражении условия

while ((y = x)> 3 )

инструкции.

while ((y = x))

инструкции.

В данном случае в первом примере в условии цикла сначала выполнится выражение в скобках, то есть значение переменной x присвоится переменной y, затем уже значение переменной y проверится на то, что оно больше 3, И если это действительно так, то цикл продолжится, если нет — то выходим из цикла.

Во втором примере всё происходит аналогично, только проверяется равенство единице, так как ИСТИНА — это 1. Две пары скобок обязательны, так как внутренние скобки — это выражение, а внешние — условие цикла. Если будут скобки только одни — получим ошибку.

Помимо базового оператора присваивания в языке C имеются комбинированные операторы присваивания, с помощью которых совместно с операцией присваивания могут выполняться арифметические и другие, в том числе побитовые операции. Такие операторы в комбинированном операторе присваивания ставятся впереди базового оператора присваивания.

Если мы обозначим оператор, комбинируемый с базовым оператором присваивания OP, а операнды справа и слева обозначим o1 b o2, то операция с применением комбинированного оператора присваивания запишется вот так

o1 OP = o2 ;

А работает комбинированный оператор так: сначала между значением переменной o1 и значением выражения o2 выполняется операция OP, а затем результат этой операции присваивается переменной o1.

То есть команда, записанная нами, будет полностью эквивалентна следующей команде:

o1 = o1 OP o2 ;

Вот примеры таких операторов:

+= — присваивание со сложением,

-= — присваивание с вычитанием,

*= — присваивание с умножением,

/= — присваивание с делением,

%= — присваивание с делением по модулю,

>= — присваивание с битовым сдвигом вправо,

А вот примеры операций с применением таких операторов

x += 5 ;

y -= x;

z *= x +5 ;

a /= 3 ;

b %= 10 ;

c

x |= 0x3A ;

y ^= 0x55 ;

z >>= 2 ;

Стоит обратить внимание вот на эту инструкцию

z *= x +5 ;

Кто-то вполне может подумать, что она эквивалентна вот такой инструкции

z = z*x +5 ;

Но, зная правило работы комбинированных операторов присваивания, которое гласит о том, что сначала вычисляется выражение справа от оператора, а уж потом выполняется операция, стоящая перед знаком =, то эквивалентная операция будет вот такая

z = z*(x +5) ;

Теперь мы немало знаем об операторах присваивания и можем смело приступить к практической части урока.

Проект сделаем из проекта MYPROG15 прошлого занятия и имя ему было присвоено MYPROG16.

Откроем файл main.c и в функции main(), как обычно, удалим весь код тела кроме возврата нуля, останется от него вот это

int main()

return 0 ; //Return an integer from a function

Удалим также вот эти константы

Функцию, преобразующую двоичное значение числа в символьный вид, оставим, ещё пригодится.

Добавим в функцию main() следующий код, в котором применим для начала самое простейшее присваивание переменной значения

Как присвоить значение переменной функции, не входящей в нее

введите сюда описание изображения

Добрый вечер. Такой вопрос, как присвоить значения переменных a и b из main’a функции sum. Никак не могу разобраться

Отслеживать
81.2k 9 9 золотых знаков 78 78 серебряных знаков 135 135 бронзовых знаков
задан 20 окт 2016 в 17:39
Men’s Phisique Men’s Phisique
101 1 1 золотой знак 3 3 серебряных знака 6 6 бронзовых знаков
Код нужно класть в виде кода, а не в виде скриншота. Не первый вопрос уже.
20 окт 2016 в 17:45

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Давайте я вас совсем запутаю, чтобы вам было что почитать.:)

Во-первых, следует стараться писать функции так, чтобы они выполняли одно конкретное действие. Ваша же функция суммирует два числа и выводит их на консоль. Если вам понадобится просто получить сумму двух числе, то вам придется писать еще одну функцию. Это можно было бы избежать, если бы ваша функция только вычисляла сумму двух числе и возвращала ее вызывающему коду.

Другая проблема с вашей функцией состоит в том, что сумма двух чисел типа int , может не умещаться в объекте этого типа, то есть может иметь место переполнение. Тогда в этом случае функцию даст неверный результат.

В принципе функция может быть определена двумя способами. Первый способ по числу параметров соответствует вашему объявлению функции. Но это единственное, с чем она схожа с определением функции, показанной мною в следующей демонстрационной программе. Я специально использовал коллизию имен sum , чтобы, как я уже сказал, вам было что почитать.:)

#include #include void sum( long long int sum = static_cast( a ) + b; > int main() < long long int sum; ::sum( sum, std::numeric_limits::max(), std::numeric_limits::max() ); std::cout << «sum of » << std::numeric_limits::max() << » + » << std::numeric_limits::max()

Вывод программы на консоль следующий

sum of 2147483647 + 2147483647 is equal to 4294967294

В языках программирования параметр функции sum, объявленный как long long int return static_cast( a ) + b; > int main() < long long int sum; sum = ::sum( std::numeric_limits::max(), std::numeric_limits::max() ); std::cout << «sum of » << std::numeric_limits::max() << » + » << std::numeric_limits::max()

Здесь значение в вызывающий код передается через значение возврата из функции.

В обоих случаях для результата используется тип long long int , который позволяет избежать переполнения, как это видно из вывода на консоль.

Что касается вашей программы, то имейте в виду, что данное предложение в main

void sum();

является локальным объявлением функции с именем sum , которая не имеет параметров и имеет тип возвращающего значения void . Это локальное объявление скрывает объявление другой функции sum , объявленной перед main .

Пример

Рассмотрим пример, где переменные были объявлены в самом верху, но определены и инициализированы внутри главной функции.

#include // Объявление переменных: extern int a, b; extern int c; extern float f; int main () < /* объявление переменных: */ int a, b; int c; float f; /* фактическая инициализация */ a = 10; b = 20; c = a + b; printf(«value of c : %d n», c); f = 70.0/3.0; printf(«value of f : %f n», f); return 0; >

Когда приведенный выше код компилируется и выполняется, выдается следующий результат:

value of c : 30
value of f : 23.333334

Тот же принцип применим к объявлению функции, когда вы указываете имя функции во время ее объявления, а ее фактическое определение может быть дано в любом другом месте. Например:

// объявление функции int func(); int main() < // вызов функции int i = func(); >// определение функции int func()

L-значения и R-значения

В языке C есть два вида выражений:

  1. L-значения. Выражения, которые ссылаются на область памяти, называются выражениями l-значения. L-значение может появляться как в левой, так и в правой части присваивания.
  2. R-значения. Термин r-значение относится к значению данных, которое хранится по некоторому адресу в памяти. R-значение — это выражение, которому не может быть присвоено значение, что означает, что r-значение может появляться только в правой части присваивания.

Переменные — это l-значения, поэтому они могут появляться в левой части присваивания. Числовые литералы являются r-значениями, поэтому их нельзя присвоить и они не могут появляться в левой части. Посмотрите на следующие допустимые и недопустимые операторы:

int g = 20; // допустимый оператор 10 = 20; // недопустимый оператор, который приведет к ошибке во время компиляции

  • Обучение программированию лучше начать с языка С. И вот почему
  • 7 моих любимых расширений VS Code
  • Курс на продуктивность: 10 бесплатных инструментов и сайтов для разработчиков
Оцените статью
TutShema
Добавить комментарий