Error lvalue required as decrement operand

The ternary operator produces a result, it does not assign a value. So an attempt to assign a value will result in an error. Observe the following ternary operator:

Many compilers will parse this as the following:

This is an error. That is because the initial ternary operator ((x>y)?y=x:y) results in an expression. That’s what we’ve done in the next code block. As a result, it leads to the error lvalue required as left operand of assignment ternary operator.

#include
int main() <
int x = 23, y;
x >= 23? y = 4: y = 12;
printf(“%d”, y);
return 0;
>

– Using Pre-increment on a Temporary Variable

An attempt to pre-increment a temporary variable will also lead to an lvalue required error. That is because a temporary variable has a short lifespan, so they tend to hold data that you’ll soon discard. Therefore, trying to increment such a variable will lead to an error.

For example, in the code below, we pre-increment a variable after we decrement it. As a result, it leads to the error lvalue required as increment operand.

#include
int main() <
int i = 5;
printf(“%dn” ++(-i)); // Error
>

– Direct Decrement of a Numeric Literal

Direct decrement of a numeric literal will lead to an error. That is because in programming, it’s illegal to decrement a numeric literal, so don’t do it, use variables instead. We’ll show you a code example so you’ll know what to avoid in your code.

In our next code block, we aim to reduce the value of X and Y variables. However, decrementing the variables directly leads to error lvalue required as decrement operand. That’s because the direct decrement is illegal, so, it’s an assignment error.

#include
int main() <
// This is illegal, don’t try this
int x, y;
x = -4–4;
y = -4–(-4);
printf(“x=%d y=%d”, x, y);
>

– Using a Pointer to a Variable Value

An attempt to use a pointer on a variable value will lead to lvalue required error. That’s because the purpose of the pointer sign (&) is to refer to the address of a variable, not the value of the variable.

In the code below, we’ve used the pointer sign (&) on the value of the Z variable. As a result, when you compile the code you get the error lvalue required as unary ‘&’ operand.

#include
int main() <
int *p;
int z = 5;
p = &5; // Here is the error
return 0;
>

– Wrong Placement of Expression

If you place an expression in the wrong place, it’ll lead to an error lvalue required as operand. It gets confusing if you assign the expression to a variable used in the expression. Therefore, this can result in you assigning the variable to itself.

The following C++ code example will result in an error. That is because we’ve incremented the variable and we assign it to itself.

The error code that reads lvalue required as left operand of assignment occurs in C-like languages. It happens when the language can not deduce if the left-hand side of a statement is an lvalue or not, thereby causing a frustrating error code to appear.

Keep on reading this guide as our experts teach you the different scenarios that can cause this error and how you can fix it. In addition, we’ll also answer some commonly-asked questions about the lvalue required error.

Why Do You Have the Error Lvalue Required as Left Operand of Assignment?

The reason you are seeing the lvalue required error is because of several reasons such as: misuse of the assignment operator, mishandling of the multiplication assignment operator, misunderstanding the ternary operator, or using pre-increment on a temporary variable. Direct decrement of a numeric literal, using a pointer to a numeric value, and wrong placement of expression can also cause this error.

The first step to take after receiving such an error is to diagnose the root cause of the problem. As you can see, there are a lot of possible causes as to why this is occurring, so we’ll take a closer look at all of them to see which one fits your experience.

– Misuse of the Assignment Operator

When you misuse the equal sign in your code, you’ll run into the lvalue required error. This occurs when you are trying to check the equality of two variables, so during the check, you might have used the equal sign instead of an equality check. As a result, when you compile the code, you’ll get the lvalue required error.

In the C code below, we aim to check for equality between zero and the result of the remainder between 26 and 13. However, in the check, we used the equal sign on the left hand of the statement. As a result, we get an error when we compare it with the right hand operand.

#include <stdio.h>
// This code will produce an error
int main() {
int a = 26;
int b = 13;
if (a % b = 0) {
printf(“%s”, “It’s all good”);
}
}

– Mishandling of the Multiplication Assignment Operator

Mishandling of the multiplication assignment operator will result in the lvalue required error. This happens if you don’t know how compilers evaluate a multiplication assignment operator. For example, you could write your statement using the following format:

variable * increment = variable

The format of this statement will cause an error because the left side is an expression, and you cannot use an expression as an lvalue. This is synonymous to 20 multiplied by 20 is equal to 20, so the code below is an assignment error.

#include <stdio.h>
int findFactorial(int n) {
int result = 1, i;
for ( i = 1; i <= n; i++) {
result*1 = result; // Here is the error
}
return result;
}
int main() {
int n = 5;
int factorial = findFactorial(n);
printf(“%d”, factorial);
return 0;
}

– Misunderstanding the Ternary Operator

The ternary operator produces a result, it does not assign a value. So an attempt to assign a value will result in an error. Observe the following ternary operator:

(x>y)?y=x:y=y

Many compilers will parse this as the following:

((x>y)?y=x:y)=y

This is an error. That is because the initial ternary operator ((x>y)?y=x:y) results in an expression. That’s what we’ve done in the next code block. As a result, it leads to the error lvalue required as left operand of assignment ternary operator.

#include <stdio.h>
int main() {
int x = 23, y;
x >= 23? y = 4: y = 12;
printf(“%d”, y);
return 0;
}

– Using Pre-increment on a Temporary Variable

An attempt to pre-increment a temporary variable will also lead to an lvalue required error. That is because a temporary variable has a short lifespan, so they tend to hold data that you’ll soon discard. Therefore, trying to increment such a variable will lead to an error.

For example, in the code below, we pre-increment a variable after we decrement it. As a result, it leads to the error lvalue required as increment operand.

#include <stdio.h>
int main() {
int i = 5;
printf(“%dn” ++(-i)); // Error
}

– Direct Decrement of a Numeric Literal

Direct decrement of a numeric literal will lead to an error. That is because in programming, it’s illegal to decrement a numeric literal, so don’t do it, use variables instead. We’ll show you a code example so you’ll know what to avoid in your code.

In our next code block, we aim to reduce the value of X and Y variables. However, decrementing the variables directly leads to error lvalue required as decrement operand. That’s because the direct decrement is illegal, so, it’s an assignment error.

#include <stdio.h>
int main() {
// This is illegal, don’t try this
int x, y;
x = -4–4;
y = -4–(-4);
printf(“x=%d y=%d”, x, y);
}

– Using a Pointer to a Variable Value

An attempt to use a pointer on a variable value will lead to lvalue required error. That’s because the purpose of the pointer sign (&) is to refer to the address of a variable, not the value of the variable.

In the code below, we’ve used the pointer sign (&) on the value of the Z variable. As a result, when you compile the code you get the error lvalue required as unary ‘&’ operand.

#include <stdio.h>
int main() {
int *p;
int z = 5;
p = &5; // Here is the error
return 0;
}

– Wrong Placement of Expression

If you place an expression in the wrong place, it’ll lead to an error lvalue required as operand. It gets confusing if you assign the expression to a variable used in the expression. Therefore, this can result in you assigning the variable to itself.

The following C++ code example will result in an error. That is because we’ve incremented the variable and we assign it to itself.

#include <iostream>
using namespace std;
int main() {
int y[3] = {3,4,5};
int *z=y;
z + 1 = z; // Error
cout << z;
return 0;
}

You can fix the lvalue required error by using equality operator during comparisons, using a counter variable as the value of the multiplication assignment operator, or using the ternary operator the right way. Not pre-incrementing a temporary variable, using pointer on a variable, not its value, and placing an expression on the right side will also help you fix this error.

Now that you know what is causing this error to appear, it’s now time to take actionable steps to fix the problem. In this section, we’ll be discussing these solutions in more detail.

– Use Equality Operator During Comparisons

During comparisons, use the equality operator after the left operand. By doing this, you’ve made it clear to the compiler that you are doing comparisons, so this will prevent an error.

The following code is the correct version of the first example in the code. We’ve added a comment to the corrected code so you can observe the difference.

#include <stdio.h>
int main() {
int a = 26;
int b = 13;
if (a % b == 0) { // Here is the correction
printf(“%s”, “It’s all good”);
}
}

– Use a Counter Variable as the Value of the Multiplication Assignment Operator

When doing computation with the multiplication assignment operator (*=), use the counter variable. Do not use another variable that can lead to an error. For example, in the code below, we’ve made changes to the second example in this article. This shows you how to prevent the error.

#include <stdio.h>
int findFactorial(int n) {
int result = 1, i;
for ( i = 1; i <=n; i++) {
result *= i; // Here is the correct part
}
return result;
}
int main() {
int n = 5;
int factorial = findFactorial(n);
printf(“%d”, factorial);
return 0;
}

– Use the Ternary Operator the Right Way

Use the ternary operator without assuming what should happen. Be explicit and use the values that will allow the ternary operator to evaluate. We present an example below.

#include <stdio.h>
int main() {
int x = 23, y;
y = x >= 23? 4: 12; // The correct ternary operation
printf(“%d”, y);
return 0;
}

– Don’t Pre-increment a Temporary Variable

That’s right, do not pre-increment a temporary variable. That’s because they only serve a temporary purpose.

At one point in this article, we showed you a code example where we use a pre-increment on a temporary variable. However, in the code below, we rewrote the code to prevent the error.

#include <stdio.h>
int main() {
int i = 5;
printf(“%dn”, (–i) * -1); // This should work as expected
}

– Use Pointer on a Variable, Not Its Value

The job of a pointer is to point to a variable location in memory, so you can make an assumption that using the variable value should work. However, it won’t work, as we’ve shown you earlier in the guide.

In the code below, we’ve placed the pointer sign (&) between the left operand and the right operand.

#include <stdio.h>
int main() {
int *p;
int z = 5;
p = &z; // This is right
printf(“%d”, p);
return 0;
}

– Place an Expression on the Right Side

When you place an expression in place of the left operand, you’ll receive an error, so it’s best to place the expression on the right side. Meanwhile, on the right, you can place the variable that gets the result of the expression.

In the following code, we have an example from earlier in the article. However, we’ve moved the expression to the right where it occupied the left operand position before.

#include <iostream>
using namespace std;
int main() {
int y[3] = {3,4,5};
int *z=y;
z = z + 1; // The correct form of assignment
cout << z;
return 0;
}

Lvalue Required: Common Questions Answered

In this section, we’ll answer questions related to the lvalue error and we’ll aim to clear further doubts you have about this error.

– What Is Meant by Left Operand of Assignment?

The left operand meaning is as follows: a modifiable value that is on the left side of an expression.

– What Is Lvalues and Rvalues?

An lvalue is a variable or an object that you can use after an expression, while an rvalue is a temporary value. As a result, once the expression is done with it, it does not persist afterward.

– What Is Lvalue in Arduino?

Lvalue in Arduino is the same as value in C, because you can use the C programming language in Arduino. However, misuse or an error could produce an error that reads error: lvalue required as left operand of assignment #define high 0x1.

What’s more, Communication Access Programming Language (CAPL) will not allow the wrong use of an lvalue. As a result, any misuse will lead to the left value required capl error. As a final note, when doing network programming in C, be wary of casting a left operand as this could lead to lvalue required as left operand of assignment struct error.

Conclusion

This article explained the different situations that will cause an lvalue error, and we also learned about the steps we can take to fix it. We covered a lot, and the following are the main points you should hold on to:

• A misuse of the assignment operator will lead to a lvalue error, and using the equality operator after the left operand will fix this issue.
• Using a pointer on the variable instead of the value will prevent the lvalue assignment error.
• A pre-increment on a temporary variable will cause the lvalue error. Do not pre-increment on a temporary variable to fix this error.
• An lvalue is a variable while an rvalue is a temporary variable.
• Place an expression in the right position to prevent an lvalue error, as the wrong placement of expressions can also cause this error to appear.

You don’t need to worry when you encounter this lvalue error as you are now well-prepared to handle the problem. Do share our guide when this topic arises in your tech conversations!

Ваш пример работает, но не могли бы вы более докладно объяснить в чем причина

прочитал я про undefined behavior в моем примере

и так точка следования у нас одна «;» объект expr изменяется только раз ++expr объект ch тоже раз при присваивании то есть изменение объектов expr и ch выполняется только по разу до точки следования, и тут начинается самое интересное… код

вызывает ту же ошибку! ну почему? ведь казалось бы порядок вычисления строго задан с помощью скобок и нет перекрытия точки следования?

Добавлено через 46 минут

Все разобрался это не undefined behavior, хвала книге K&R expr в моем случае это имя массива указателей на чар, который нельзя инкрементировать(изменять) и который в частном случае может быть указателем на массив указателей. но его же изменять нельзя что я пытался сделать

Данная проблема решается объявлением указателя на указатель:

1
2
3
4
5
6

 char *expr[] = {"my", "w9rd", "the"};
      char **p_char;
 
      p_char = expr;
      ch = (*++p_char)[2];
      std::cout << ch;

все впорядке выводится символ ‘r’

Начнём-с с C:

main(){
 int i = 0; 
 --i++;
}

при попытке собрать:

$ gcc main.c -o main
main.c: In function 'main':
main.c:3: error: lvalue required as decrement operand

Внимательно читаем о Lvalue:

In C, the term L-value originally meant something that could be assigned to (coming from left-value, indicating it was on the left side of the = operator)

Т.о. декремент должен быть применён к lvalue, но для Си i++ не есть lvalue.
Схожая ситуация и с Java, javascript.

C++ так же ругается на ошибку, но если расставить скобки, то код работает.

#include <iostream>
int main(){
 int i = 0;
 std::cout << "(--i)++: " << (--i)++ << ", i: " << i << std::endl;
}

$ g++ main.cpp -o main && ./main 
(--i)++: -1, i: 0

В C++ действует т.н. временная переменная, которой и происходит присваивание временного же значения, которая в итоге будет присвоена обратно i.

А вот, что google выдаёт по запросу «(—i)++» lang:c++:

 805:   {
  intelhex::lst_dblock::const_iterator prev = (--i)++;    //Get an iterator to the previous element w/o changing i
  //Check for gaps between blocks and fill them with NOP's

Логично, предположить, что схожим образом будут действовать и итераторы, для которых определены операции инкремента и декремента:

#include <iostream>
#include <vector>
int main(){
 std::vector<int> v;
 v.push_back( 5 );
 v.push_back( 7 );
 v.push_back( 9 );
 for(std::vector<int>::iterator it = v.begin(); it != v.end(); ++it){
   if (it != v.begin())
    std::cout << "prev:" << *(--it)++ << std::endl;     
   std::cout << *it << std::endl;
 }
}

Результат:

5
prev:5
7
prev:7
9

ps. Вот такой вот он «красивый» этот C++ — и как только ещё смеют говорить C++шники, что тернарный оператор сложно читать…