Expression must be a modifiable lvalue ошибка

As you use conditional statements in c++ you may come across expression must be a modifiable lvalue error. You are likely to see this error message in most conditional expressions when using the assignment operator (=) instead of the comparison operator (==). In this post, you will learn the cause of this error and how you can solve it.

You will get this error message as a result of an expression not producing an lvalue (value on the left side of an assignment). The “l” in the “lvalue” stands for something on the left side of the (=) operator. It means you are attempting to give the value on the right a place in the memory whose name is on the left.

Therefore, whatever is on the left should denote something that has an allocation in memory and lets you modify it. However, if you accidentally try to assign something that is not a left operand an assignment operator (=) instead of a comparison operator (==), you will get this error.

– Example One: Triggering Expression Must Be a Modifiable Lvalue in C++

Suppose you are trying to compare if the sum of two numbers is equal to the third number in C++. One way you can accomplish this is through conditional statements. Here is an example of how you can trigger this error using an assignment operator instead of a comparison operator.

#include <iostream>
using namespace std;
int main()
{
int X = 2;
int Y = 1;
int Z = 3;
// This is the same as if ( X + Y = Z )
if ( (X + Y) = Z) // Error arising from assignment operator (=)
{
std::cout << ” Comparison match” << std::endl;
}
return 0;
}

In this example, you are assigning Z variable an expression (X+Y). Thus, the compiler is going to throw the lvalue error. Every binary + operator results in rvlaue. So, the expression X + Y =Z is an error. Usually, the binary operator (+) takes high precedence over the assignment operator (=). As such X+Y is an rvalue.

Sometimes an operator may use an lvalue operand but result in rvalue. A good example of such an operator is the unary & operator.

– Example Two

Suppose you now want to do a comparison of values by combining the comparison operator and &&. Here is an example of how you can trigger this error by using the assignment operator instead of the comparison operator.

#include <iostream>
using namespace std;
int main()
{
int X = 2;
int Y = 3;
int Z = 3;
if (X == 2 && Y = Z) // Error arising from assignment operator (=)
{
std::cout << “Comparison is a match” << std::endl;
}
return 0;
}

– Example Three

Suppose you have variable A that you wish to print if the value is equal to a certain value. If in the condition statement you end up providing the value of A as the lvalue instead of A, the c++ compiler will throw this error.

#include <iostream>
using namespace std;
int main()
{
int A = 20;
if (20 = A) // *** If you run this program, this line will throw the error.
{
printf(“The value of A is 20.n”);
}
}

The condition statement uses an expression that tries to assign A to the literal value 20. It will generate the error because 20 is not a valid lvalue.

How To Solve This Error

Since the root cause of the error is the wrong use of the assignment operator when creating conditional statements, the solution is quite easy. You only need to take a quick look at the conditional statement to establish the source of the error.

– The Solution to Example One

Say you want to solve the error you got from the first example where you were comparing the sum of two numbers to a third number. You can easily get rid of this error as follows:

#include <iostream>
using namespace std;
int main()
{
int X = 2;
int Y = 1;
int Z = 3;
// This is the same as if ( X + Y == Z )
if ( (X + Y) == Z) // Solution requires replacing assignment operator (=) with a comparison operator (==)
{
std::cout << ” Comparison is a match” << std::endl;
}
return 0;
}

To resolve this error you need to ensure you do not assign Z variable to an expression X + Y like so (X + Y = Z). Instead, use the comparison operator (==). This simple modification of the code will solve this conditional statement error.

Another thing you should keep in mind is that you need to use brackets to make it easy to understand the code. Also, brackets help you get rid of precedence errors.

– The Solution to Example Two

In example two, you were comparing three numbers a pair at a time. In this example, you introduced the && which has higher precedence than the assignment operator. To solve the error in this example, you need to use the comparison operator instead of the assignment operator. So, the condition should be (X == 2 && Y == Z) to eradicate this error.

#include <iostream>
using namespace std;
int main()
{
int X = 2;
int Y = 3;
int Z = 3;
// The same as if ((X == 2) && (Y == Z))
if (X == 2 && Y == Z) // Solved the error arising from assignment operator (=)
{
std::cout << “Comparison is a match” << std::endl;
}
return 0;
}

– The Solution to Example Three

If you recall, in example three, you mistakenly used the value of A as an lvalue in your conditional expression resulting in this error. To get rid of the error, ensure you properly use operands in the condition statement. Here is how you can solve this error:

#include <iostream>
using namespace std;
int main()
{
int A = 20;
if (A = 20) // *** The erroneus (20 = A) has been solved. If you run this program, this line will not throw the error.
{
printf(“The value of A is 20.n”);
}
}

FAQ Section

– What Is the Meaning of Expression Must Be a Modifiable value?

The error indicates that the lvalue (the value on the left-hand side) in a conditional statement is not modifiable. It means you are attempting to assign something to an operand that does not belong to the left side of the assignment operator (=).

– What Does Lvalue Mean?

In c++, an lvalue is a value permitted to be on the left-hand side of the assignment operator (=). The lvalue allows examination or alteration of the designated object. However, there are object types you cannot modify such as arrays, const-qualified, and incomplete types. As such, these values cannot appear on the left side of the assignment operator.

For instance, the variable A can be lvalue that you can modify to be 20 using the assignment operator. However, note that you cannot use 20 as the lvalue for A. Usually, the lvalue is addressable and assignable.

– What Triggers Lvalue Required Error?

The error arises when you put constants as lvalue and variables on the right-hand side of the assignment operator. It means you are unable to assign a value to constants or anything without a memory address. In essence, to assign a value you need a variable.

– What Is an Rvalue and Lvalue in C++?

In c++ expressions, both rvalues and lvalues are important. In simple terms, the lvalue acts as an object reference while the rvalue is the value. The differences between rvalues and lvalues appear when you start writing expressions.

– In C++, What Is a Universal Reference

The && in type declarations showcase either a universal reference or rvalue reference. A universal value in c++ can either be an lvalue or rvalue reference.

– What Is the Meaning of Lvalue Required as Increment Operand?

Usually, any pre-increment operator demands an lvalue as an operand. If it is not present, the compiler will throw this error. Both decrement and increment operators must update the operand at every sequence point hence the need for an lvalue. Unary operators like + and – do not need an lvalue as an operand. Thus, -(++i) expression is valid.

– Which Operator Can You Use To Find the Lvalue of a Variable?

The assignment operator (=) holds the value of a variable. In other words, it assigns a variable its value.

– What Is an Expression in C++

In c++, an expression denotes a statement that contains both a data type and a value. For instance, a declaration statement defines a variable. You can think of it as a holding tank for a value such as a character or a number.

– When Should an Expression in C++ Be Modifiable?

In all conditional expressions especially when using the assignment operator (=) instead of the comparison operator (==).

Conclusion

If you get the lvalue error from a c++ compiler, you should look out for the following tell-tale signs:

• Check the conditional statements in your program
• Establish if you are using the assignment operator (=) instead of a comparison operator (==)
• Check if you are correctly applying the operator precedence in your expression
• Use brackets in expressions and comparisons to avoid mistakes

That’s it! Whenever a c++ compiler throws the lvalue error, you can now easily pinpoint and solve it.

#include <mega8.h>
#include <lcd.h>
#include <delay.h>
#include <stdio.h>
#include <stdlib.h>

#define ADC_VREF_TYPE 0x00
#define V 5

// Инициализация LCD
#asm
   .equ __lcd_port=0x18 ;PORTB
#endasm

//Функция для работы с АЦП
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
delay_us(10);
ADCSRA|=0x40;
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}

void main(void)
{
char acpread[5];
char acptry[5];
int j;

PORTB=0x00; //скорее всего нужно настроить на вывод
DDRB=0x00;

PORTC=0x00;
DDRC=0x00;

PORTD=0x00;
DDRD=0x00;

TCCR0=0x00;  //Регистр управления таймером
TCNT0=0x00;  //Счетный регистр
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;  //Регистр сравнения
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
ASSR=0x00;    //Регистр таймера в ассинхроном режиме
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
MCUCR=0x00;
TIMSK=0x00;   //Разрешение и запрет прерываний по таймеру
UCSRA=0x00;   //Регистры управления и состояни
UCSRB=0x18;   //Регистры управления и состояни
UCSRC=0x86;   //Регистры управления и состояни
UBRRH=0x00;   //Регистры ввода-вывода
UBRRL=0x4D;
ACSR=0x80;
SFIOR=0x00;
ADMUX=ADC_VREF_TYPE & 0xff;  //Регистр управления мультиплексером
ADCSRA=0x85;  //Регистр управления АЦП

lcd_init(16); // Инициализация ЖК
while (1)
      {
      itoa(read_adc(1), acpread);
      acptry = acpread*V/1024;
      j = 0;      //цикл для вывода значения с фотодатчика
      lcd_gotoxy(0,0);
      while(j<3){
      lcd_putchar(acptry[j]);
      delay_ms(200);
      j++;
      }
      }
};