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

Introduction

You may encounter the following message if you move code to another version of the IAR C/C++ Compiler:

Error[Pe137]: expression must be a modifiable lvalue

This message occurs because a cast does not produce an lvalue (that is, a value that can be used on the left side of an assignment).

Also note that a casted expression that is used with the * operator does produce an lvalue, which is why the following is OK:

void f (void * ptr)
{
   *(long *)ptr = 0x11223344L;
}

How to get rid of the error message

There are a couple of ways to rework the code to avoid this error message.

The best way is probably to rework the types so that the cast do not appear in the first place, if possible.

An alternative is to use a temporary variable of the desired type.

The following example fails:

void f (void *ptr)
{
   ((short *)ptr)++; // error
}

You can rewrite it to:

void f (void *ptr)
{
   short *temp = ptr;
   temp++;
   ptr = temp;
}

Technical details

The reason why it does not work is that a cast does not produce an lvalue (ISO/ANSI 9899-1990 6.3.4 and Annex B which describes the syntax of C).

From ISO/ANSI 9899-1990 6.3.4, cast operators, footnote 44: «A cast does not yield an lvalue. […]».

An extract from Annex B follows below:

unary-expression:
postfix-expression
++ unary-expression
-- unary-expression
unary-operator cast-expression
sizeof unary-expression
sizeof ( type-name )

unary-operator: one of
& * + - ~ !

cast-expression:
unary-expression
( type-name ) cast-expression

conditional-expression:
logical-OR-expression
logical-OR-expression ? expression : conditional-expression

assignment-expression:
conditional-expression
unary-expression assignment-operator assignment-exression

assignment-operator: one of 
= *= /= %= += -= <<= >>= &= ^= |=

The assignment requires a unary-expression on the left side. A cast-expression is not part of a unary-expression. As mentioned above, you can use a unary-operator before the cast-expression to get a unary-expression, such as ‘*‘.

Many compilers permit cast expressions on the left side of an assignment, including several produced by IAR Systems. We have since then switched to another C parser that is more restrictive on this, and besides, it is not proper ISO/ANSI C code.

All product names are trademarks or registered trademarks of their respective owners.

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.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

//Read array. Put them in a file. Read the file and fill an array of struct door #include <iostream> #include <fstream> #include <cstdlib> #include <string> using namespace std; void readatof(int x[], int y[], int n); struct door { int length[10], width[10]; }; int main() { int length[]={10,20,30,40,50,60,70,80,90,100}; int width[]={5,10,15,20,25,30,35,40,45,50}; readatof(length, width, 10); fstream arrayFile; arrayFile.open("C://Users//Esmeralda//Desktop//arrays.txt",ios::in); if (arrayFile.fail()) { cout << "Error openning file" << endl; exit(0); } door tab[10]; arrayFile >> length[10] >> width[10]; for(int i=0;i<10;i++) { tab[i].length = length; //error: Expression must be a modifiable lvalue tab[i].width = width; //error: Expression must be a modifiable lvalue arrayFile >> length[10] >> width[10]; } arrayFile.close(); system("pause"); return 0; } void readatof(int x[], int y[], int n) { fstream arrayFile; arrayFile.open("C://Users//Esmeralda//Desktop//arrays.txt",ios::out); if (arrayFile.fail()){exit(0);} for (int i=0;i<n;i++) { arrayFile << x[i] << "t" << y[i] << endl; } arrayFile.close(); }