c assignment statement function

• C Data Types
• C Operators
• C Input and Output
• C Control Flow
• C Functions
• C Preprocessors
• C File Handling
• C Cheatsheet
• C Interview Questions

Assignment Operators in C

Assignment operators are used for assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of the variable on the left side otherwise the compiler will raise an error.

Different types of assignment operators are shown below:

1. “=”: This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left. Example:

2. “+=” : This operator is combination of ‘+’ and ‘=’ operators. This operator first adds the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a += 6) = 11.

3. “-=” This operator is combination of ‘-‘ and ‘=’ operators. This operator first subtracts the value on the right from the current value of the variable on left and then assigns the result to the variable on the left. Example:

If initially value stored in a is 8. Then (a -= 6) = 2.

4. “*=” This operator is combination of ‘*’ and ‘=’ operators. This operator first multiplies the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a *= 6) = 30.

5. “/=” This operator is combination of ‘/’ and ‘=’ operators. This operator first divides the current value of the variable on left by the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 6. Then (a /= 2) = 3.

Below example illustrates the various Assignment Operators:

Please Login to comment...

Similar reads.

• C-Operators
• cpp-operator
• Best Twitch Extensions for 2024: Top Tools for Viewers and Streamers
• Discord Emojis List 2024: Copy and Paste
• Best Adblockers for Twitch TV: Enjoy Ad-Free Streaming in 2024
• PS4 vs. PS5: Which PlayStation Should You Buy in 2024?
• Full Stack Developer Roadmap [2024 Updated]

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• C Programming Tutorial
• Basics of C
• C - Overview
• C - Features
• C - History
• C - Environment Setup
• C - Program Structure
• C - Hello World
• C - Compilation Process
• C - Comments
• C - Keywords
• C - Identifiers
• C - User Input
• C - Basic Syntax
• C - Data Types
• C - Variables
• C - Integer Promotions
• C - Type Conversion
• C - Type Casting
• C - Booleans
• Constants and Literals in C
• C - Constants
• C - Literals
• C - Escape sequences
• C - Format Specifiers
• Operators in C
• C - Operators
• C - Arithmetic Operators
• C - Relational Operators
• C - Logical Operators
• C - Bitwise Operators
• C - Assignment Operators
• C - Unary Operators
• C - Increment and Decrement Operators
• C - Ternary Operator
• C - sizeof Operator
• C - Operator Precedence
• C - Misc Operators
• Decision Making in C
• C - Decision Making
• C - if statement
• C - if...else statement
• C - nested if statements
• C - switch statement
• C - nested switch statements
• C - While loop
• C - For loop
• C - Do...while loop
• C - Nested loop
• C - Infinite loop
• C - Break Statement
• C - Continue Statement
• C - goto Statement
• Functions in C
• C - Functions
• C - Main Function
• C - Function call by Value
• C - Function call by reference
• C - Nested Functions
• C - Variadic Functions
• C - User-Defined Functions
• C - Callback Function
• C - Return Statement
• C - Recursion
• Scope Rules in C
• C - Scope Rules
• C - Static Variables
• C - Global Variables
• Arrays in C
• C - Properties of Array
• C - Multi-Dimensional Arrays
• C - Passing Arrays to Function
• C - Return Array from Function
• C - Variable Length Arrays
• Pointers in C
• C - Pointers
• C - Pointers and Arrays
• C - Applications of Pointers
• C - Pointer Arithmetics
• C - Array of Pointers
• C - Pointer to Pointer
• C - Passing Pointers to Functions
• C - Return Pointer from Functions
• C - Function Pointers
• C - Pointer to an Array
• C - Pointers to Structures
• C - Chain of Pointers
• C - Pointer vs Array
• C - Character Pointers and Functions
• C - NULL Pointer
• C - void Pointer
• C - Dangling Pointers
• C - Dereference Pointer
• C - Near, Far and Huge Pointers
• C - Initialization of Pointer Arrays
• C - Pointers vs. Multi-dimensional Arrays
• Strings in C
• C - Strings
• C - Array of Strings
• C - Special Characters
• C Structures and Unions
• C - Structures
• C - Structures and Functions
• C - Arrays of Structures
• C - Self-Referential Structures
• C - Lookup Tables
• C - Dot (.) Operator
• C - Enumeration (or enum)
• C - Structure Padding and Packing
• C - Nested Structures
• C - Anonymous Structure and Union
• C - Bit Fields
• C - Typedef
• File Handling in C
• C - Input & Output
• C - File I/O (File Handling)
• C Preprocessors
• C - Preprocessors
• C - Pragmas
• C - Preprocessor Operators
• C - Header Files
• Memory Management in C
• C - Memory Management
• C - Memory Address
• C - Storage Classes
• Miscellaneous Topics
• C - Error Handling
• C - Variable Arguments
• C - Command Execution
• C - Math Functions
• C - Static Keyword
• C - Random Number Generation
• C - Command Line Arguments
• C Programming Resources
• C - Questions & Answers
• C - Quick Guide
• C - Cheat Sheet
• C - Useful Resources
• C - Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Assignment Operators in C

In C language, the assignment operator stores a certain value in an already declared variable. A variable in C can be assigned the value in the form of a literal, another variable, or an expression.

The value to be assigned forms the right-hand operand, whereas the variable to be assigned should be the operand to the left of the " = " symbol, which is defined as a simple assignment operator in C.

In addition, C has several augmented assignment operators.

The following table lists the assignment operators supported by the C language −

Simple Assignment Operator (=)

The = operator is one of the most frequently used operators in C. As per the ANSI C standard, all the variables must be declared in the beginning. Variable declaration after the first processing statement is not allowed.

You can declare a variable to be assigned a value later in the code, or you can initialize it at the time of declaration.

You can use a literal, another variable, or an expression in the assignment statement.

Once a variable of a certain type is declared, it cannot be assigned a value of any other type. In such a case the C compiler reports a type mismatch error.

In C, the expressions that refer to a memory location are called "lvalue" expressions. A lvalue may appear as either the left-hand or right-hand side of an assignment.

On the other hand, the term rvalue refers to a data value that is stored at some address in memory. A rvalue is an expression that cannot have a value assigned to it which means an rvalue may appear on the right-hand side but not on the left-hand side of an assignment.

Variables are lvalues and so they may appear on the left-hand side of an assignment. Numeric literals are rvalues and so they may not be assigned and cannot appear on the left-hand side. Take a look at the following valid and invalid statements −

Augmented Assignment Operators

In addition to the = operator, C allows you to combine arithmetic and bitwise operators with the = symbol to form augmented or compound assignment operator. The augmented operators offer a convenient shortcut for combining arithmetic or bitwise operation with assignment.

For example, the expression "a += b" has the same effect of performing "a + b" first and then assigning the result back to the variable "a".

Run the code and check its output −

Similarly, the expression "a <<= b" has the same effect of performing "a << b" first and then assigning the result back to the variable "a".

Here is a C program that demonstrates the use of assignment operators in C −

When you compile and execute the above program, it will produce the following result −

01 Career Opportunities

02 beginner, 03 intermediate, 04 advanced, 05 training programs, c programming assignment operators, free c programming online course with certificate, what is an assignment operator in c, types of assignment operators in c.

1. Simple Assignment Operator (=)

Example of simple assignment operator.

2. Compound Assignment Operators

Example of Augmented Arithmetic and Assignment Operators

Example of Augmented Bitwise and Assignment Operators

Practice problems on assignment operators in c, 1. what will the value of "x" be after the execution of the following code, 2. after executing the following code, what is the value of the number variable, benefits of using assignment operators, best practices and tips for using the assignment operator, live classes schedule.

About Author

Home » Learn C Programming from Scratch » C Assignment Operators

C Assignment Operators

Summary : in this tutorial, you’ll learn about the C assignment operators and how to use them effectively.

Introduction to the C assignment operators

An assignment operator assigns the vale of the right-hand operand to the left-hand operand. The following example uses the assignment operator (=) to assign 1 to the counter variable:

After the assignmment, the counter variable holds the number 1.

The following example adds 1 to the counter and assign the result to the counter:

The = assignment operator is called a simple assignment operator. It assigns the value of the left operand to the right operand.

Besides the simple assignment operator, C supports compound assignment operators. A compound assignment operator performs the operation specified by the additional operator and then assigns the result to the left operand.

The following example uses a compound-assignment operator (+=):

The expression:

is equivalent to the following expression:

The following table illustrates the compound-assignment operators in C:

• A simple assignment operator assigns the value of the left operand to the right operand.
• A compound assignment operator performs the operation specified by the additional operator and then assigns the result to the left operand.

Assignment and shorthand assignment operator in C

Quick links.

• Shorthand assignment

Assignment operator is used to assign value to a variable (memory location). There is a single assignment operator = in C. It evaluates expression on right side of = symbol and assigns evaluated value to left side the variable.

For example consider the below assignment table.

The RHS of assignment operator must be a constant, expression or variable. Whereas LHS must be a variable (valid memory location).

Shorthand assignment operator

C supports a short variant of assignment operator called compound assignment or shorthand assignment. Shorthand assignment operator combines one of the arithmetic or bitwise operators with assignment operator.

For example, consider following C statements.

The above expression a = a + 2 is equivalent to a += 2 .

Similarly, there are many shorthand assignment operators. Below is a list of shorthand assignment operators in C.

C Programming Tutorial

• Assignment Operator in C

Last updated on July 27, 2020

We have already used the assignment operator ( = ) several times before. Let's discuss it here in detail. The assignment operator ( = ) is used to assign a value to the variable. Its general format is as follows:

The operand on the left side of the assignment operator must be a variable and operand on the right-hand side must be a constant, variable or expression. Here are some examples:

The precedence of the assignment operator is lower than all the operators we have discussed so far and it associates from right to left.

We can also assign the same value to multiple variables at once.

here x , y and z are initialized to 100 .

Since the associativity of the assignment operator ( = ) is from right to left. The above expression is equivalent to the following:

Note that expressions like:

are called assignment expression. If we put a semicolon( ; ) at the end of the expression like this:

then the assignment expression becomes assignment statement.

Compound Assignment Operator #

Assignment operations that use the old value of a variable to compute its new value are called Compound Assignment.

Consider the following two statements:

Here the second statement adds 5 to the existing value of x . This value is then assigned back to x . Now, the new value of x is 105 .

To handle such operations more succinctly, C provides a special operator called Compound Assignment operator.

The general format of compound assignment operator is as follows:

where op can be any of the arithmetic operators ( + , - , * , / , % ). The above statement is functionally equivalent to the following:

Note : In addition to arithmetic operators, op can also be >> (right shift), << (left shift), | (Bitwise OR), & (Bitwise AND), ^ (Bitwise XOR). We haven't discussed these operators yet.

After evaluating the expression, the op operator is then applied to the result of the expression and the current value of the variable (on the RHS). The result of this operation is then assigned back to the variable (on the LHS). Let's take some examples: The statement:

is equivalent to x = x + 5; or x = x + (5); .

Similarly, the statement:

is equivalent to x = x * 2; or x = x * (2); .

Since, expression on the right side of op operator is evaluated first, the statement:

is equivalent to x = x * (y + 1) .

The precedence of compound assignment operators are same and they associate from right to left (see the precedence table ).

The following table lists some Compound assignment operators:

The following program demonstrates Compound assignment operators in action:

Expected Output:

Load Comments

• Intro to C Programming
• Installing Code Blocks
• Creating and Running The First C Program
• Basic Elements of a C Program
• Keywords and Identifiers
• Data Types in C
• Constants in C
• Variables in C
• Input and Output in C
• Formatted Input and Output in C
• Arithmetic Operators in C
• Operator Precedence and Associativity in C
• Increment and Decrement Operators in C
• Relational Operators in C
• Logical Operators in C
• Conditional Operator, Comma operator and sizeof() operator in C
• Implicit Type Conversion in C
• Explicit Type Conversion in C
• if-else statements in C
• The while loop in C
• The do while loop in C
• The for loop in C
• The Infinite Loop in C
• The break and continue statement in C
• The Switch statement in C
• Function basics in C
• The return statement in C
• Actual and Formal arguments in C
• Local, Global and Static variables in C
• Recursive Function in C
• One dimensional Array in C
• One Dimensional Array and Function in C
• Two Dimensional Array in C
• Pointer Basics in C
• Pointer Arithmetic in C
• Pointers and 1-D arrays
• Pointers and 2-D arrays
• Call by Value and Call by Reference in C
• Returning more than one value from function in C
• Returning a Pointer from a Function in C
• Passing 1-D Array to a Function in C
• Passing 2-D Array to a Function in C
• Array of Pointers in C
• Void Pointers in C
• The malloc() Function in C
• The calloc() Function in C
• The realloc() Function in C
• String Basics in C
• The strlen() Function in C
• The strcmp() Function in C
• The strcpy() Function in C
• The strcat() Function in C
• Character Array and Character Pointer in C
• Array of Strings in C
• Array of Pointers to Strings in C
• The sprintf() Function in C
• The sscanf() Function in C
• Structure Basics in C
• Array of Structures in C
• Array as Member of Structure in C
• Nested Structures in C
• Pointer to a Structure in C
• Pointers as Structure Member in C
• Structures and Functions in C
• Union Basics in C
• typedef statement in C
• Basics of File Handling in C
• fputc() Function in C
• fgetc() Function in C
• fputs() Function in C
• fgets() Function in C
• fprintf() Function in C
• fscanf() Function in C
• fwrite() Function in C
• fread() Function in C

Recent Posts

• Machine Learning Experts You Should Be Following Online
• 4 Ways to Prepare for the AP Computer Science A Exam
• Finance Assignment Online Help for the Busy and Tired Students: Get Help from Experts
• Top 9 Machine Learning Algorithms for Data Scientists
• Data Science Learning Path or Steps to become a data scientist Final
• Enable Edit Button in Shutter In Linux Mint 19 and Ubuntu 18.04
• Python 3 time module
• Pygments Tutorial
• How to use Virtualenv?
• Installing MySQL (Windows, Linux and Mac)
• What is if __name__ == '__main__' in Python ?
• Installing GoAccess (A Real-time web log analyzer)
• Installing Isso

cppreference.com

Assignment operators.

Assignment operators modify the value of the object.

[ edit ] Definitions

Copy assignment replaces the contents of the object a with a copy of the contents of b ( b is not modified). For class types, this is performed in a special member function, described in copy assignment operator .

For non-class types, copy and move assignment are indistinguishable and are referred to as direct assignment .

Compound assignment replace the contents of the object a with the result of a binary operation between the previous value of a and the value of b .

[ edit ] Assignment operator syntax

The assignment expressions have the form

• ↑ target-expr must have higher precedence than an assignment expression.
• ↑ new-value cannot be a comma expression, because its precedence is lower.

[ edit ] Built-in simple assignment operator

For the built-in simple assignment, the object referred to by target-expr is modified by replacing its value with the result of new-value . target-expr must be a modifiable lvalue.

The result of a built-in simple assignment is an lvalue of the type of target-expr , referring to target-expr . If target-expr is a bit-field , the result is also a bit-field.

[ edit ] Assignment from an expression

If new-value is an expression, it is implicitly converted to the cv-unqualified type of target-expr . When target-expr is a bit-field that cannot represent the value of the expression, the resulting value of the bit-field is implementation-defined.

If target-expr and new-value identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same).

In overload resolution against user-defined operators , for every type T , the following function signatures participate in overload resolution:

For every enumeration or pointer to member type T , optionally volatile-qualified, the following function signature participates in overload resolution:

For every pair A1 and A2 , where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signature participates in overload resolution:

[ edit ] Built-in compound assignment operator

The behavior of every built-in compound-assignment expression target-expr   op   =   new-value is exactly the same as the behavior of the expression target-expr   =   target-expr   op   new-value , except that target-expr is evaluated only once.

The requirements on target-expr and new-value of built-in simple assignment operators also apply. Furthermore:

• For + = and - = , the type of target-expr must be an arithmetic type or a pointer to a (possibly cv-qualified) completely-defined object type .
• For all other compound assignment operators, the type of target-expr must be an arithmetic type.

In overload resolution against user-defined operators , for every pair A1 and A2 , where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signatures participate in overload resolution:

For every pair I1 and I2 , where I1 is an integral type (optionally volatile-qualified) and I2 is a promoted integral type, the following function signatures participate in overload resolution:

For every optionally cv-qualified object type T , the following function signatures participate in overload resolution:

[ edit ] Example

Possible output:

[ edit ] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[ edit ] See also

Operator precedence

Operator overloading

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 25 January 2024, at 23:41.
• Privacy policy
• About cppreference.com
• Disclaimers

Learn C practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c interactively, c introduction.

• Getting Started with C
• Your First C Program

C Fundamentals

• C Variables, Constants and Literals
• C Data Types
• C Input Output (I/O)
• C Programming Operators

C Flow Control

• C if...else Statement
• C while and do...while Loop
• C break and continue
• C switch Statement
• C goto Statement
• C Functions
• C User-defined functions
• Types of User-defined Functions in C Programming

C Recursion

• C Storage Class

C Programming Arrays

• C Multidimensional Arrays
• Pass arrays to a function in C

C Programming Pointers

• Relationship Between Arrays and Pointers
• C Pass Addresses and Pointers
• C Dynamic Memory Allocation
• C Array and Pointer Examples
• C Programming Strings
• String Manipulations In C Programming Using Library Functions

String Examples in C Programming

C Structure and Union

• C structs and Pointers
• C Structure and Function

C Programming Files

• C File Handling
• C Files Examples

C Additional Topics

• C Keywords and Identifiers
• C Precedence And Associativity Of Operators
• C Bitwise Operators
• C Preprocessor and Macros
• C Standard Library Functions

C Tutorials

• Check Prime or Armstrong Number Using User-defined Function

C Control Flow Examples

• Check Whether a Number can be Expressed as Sum of Two Prime Numbers
• Convert Binary Number to Octal and vice-versa
• Find Factorial of a Number Using Recursion

C Function Examples

A function is a block of code that performs a specific task.

You will find examples related to functions in this article. To understand examples in this page, you should have the knowledge of the following topics:

• User-Defined Function
• Types of User-defined functions
• Scope of a local variable

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

• Interactive Courses
• Certificates
• 2000+ Challenges

Related Tutorials

C Struct Examples

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Assignment operators

• 8 contributors

expression assignment-operator expression

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

Assignment operators store a value in the object specified by the left operand. There are two kinds of assignment operations:

simple assignment , in which the value of the second operand is stored in the object specified by the first operand.

compound assignment , in which an arithmetic, shift, or bitwise operation is performed before storing the result.

All assignment operators in the following table except the = operator are compound assignment operators.

Assignment operators table

Operator keywords

Three of the compound assignment operators have keyword equivalents. They are:

C++ specifies these operator keywords as alternative spellings for the compound assignment operators. In C, the alternative spellings are provided as macros in the <iso646.h> header. In C++, the alternative spellings are keywords; use of <iso646.h> or the C++ equivalent <ciso646> is deprecated. In Microsoft C++, the /permissive- or /Za compiler option is required to enable the alternative spelling.

Simple assignment

The simple assignment operator ( = ) causes the value of the second operand to be stored in the object specified by the first operand. If both objects are of arithmetic types, the right operand is converted to the type of the left, before storing the value.

Objects of const and volatile types can be assigned to l-values of types that are only volatile , or that aren't const or volatile .

Assignment to objects of class type ( struct , union , and class types) is performed by a function named operator= . The default behavior of this operator function is to perform a member-wise copy assignment of the object's non-static data members and direct base classes; however, this behavior can be modified using overloaded operators. For more information, see Operator overloading . Class types can also have copy assignment and move assignment operators. For more information, see Copy constructors and copy assignment operators and Move constructors and move assignment operators .

An object of any unambiguously derived class from a given base class can be assigned to an object of the base class. The reverse isn't true because there's an implicit conversion from derived class to base class, but not from base class to derived class. For example:

Assignments to reference types behave as if the assignment were being made to the object to which the reference points.

For class-type objects, assignment is different from initialization. To illustrate how different assignment and initialization can be, consider the code

The preceding code shows an initializer; it calls the constructor for UserType2 that takes an argument of type UserType1 . Given the code

the assignment statement

can have one of the following effects:

Call the function operator= for UserType2 , provided operator= is provided with a UserType1 argument.

Call the explicit conversion function UserType1::operator UserType2 , if such a function exists.

Call a constructor UserType2::UserType2 , provided such a constructor exists, that takes a UserType1 argument and copies the result.

Compound assignment

The compound assignment operators are shown in the Assignment operators table . These operators have the form e1 op = e2 , where e1 is a non- const modifiable l-value and e2 is:

an arithmetic type

a pointer, if op is + or -

a type for which there exists a matching operator *op*= overload for the type of e1

The built-in e1 op = e2 form behaves as e1 = e1 op e2 , but e1 is evaluated only once.

Compound assignment to an enumerated type generates an error message. If the left operand is of a pointer type, the right operand must be of a pointer type, or it must be a constant expression that evaluates to 0. When the left operand is of an integral type, the right operand must not be of a pointer type.

Result of built-in assignment operators

The built-in assignment operators return the value of the object specified by the left operand after the assignment (and the arithmetic/logical operation in the case of compound assignment operators). The resultant type is the type of the left operand. The result of an assignment expression is always an l-value. These operators have right-to-left associativity. The left operand must be a modifiable l-value.

In ANSI C, the result of an assignment expression isn't an l-value. That means the legal C++ expression (a += b) += c isn't allowed in C.

Expressions with binary operators C++ built-in operators, precedence, and associativity C assignment operators

Was this page helpful?

Additional resources

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

When would you want to assign a variable in an if condition? [duplicate]

I recently just lost some time figuring out a bug in my code which was caused by a typo:

instead of:

I was wondering if there is any particular case you would want to assign a value to a variable in a if statement, or if not, why doesn't the compiler throw a warning or an error?

• if-statement

• 4 I depends, my compiler throws a warning when a = b –  user1944441 Commented Jul 16, 2013 at 16:03
• 3 The compiler doesn't issue a diagnostic because it is not mandated to do so. It is perfectly valid C++ code. –  Alok Save Commented Jul 16, 2013 at 16:05
• 7 Most compilers will warn about this, as long as you enable the warning. –  Mike Seymour Commented Jul 16, 2013 at 16:07
• 3 I vote against treating this as a duplicate of stackoverflow.com/q/151850/2932052 , because this is an actual C/C++ question that arises often whereas the other is very vague and language-agnostic. Maybe it's really only a C/C++ problem? In this case the other should get the tag and this question should be treated as duplicate. –  Wolf Commented Apr 23, 2019 at 9:27
• 2 Does this answer your question? Inadvertent use of = instead of == –  outis Commented Jun 30, 2022 at 5:42

9 Answers 9

Though this is oft cited as an anti-pattern ("use virtual dispatch!"), sometimes the Derived type has functionality that the Base simply does not (and, consequently, distinct functions), and this is a good way to switch on that semantic difference.

• 17 The anti-pattern is putting a definition in the condition. It's a sure recipe for unreadable and unmaintainable code. –  James Kanze Commented Jul 16, 2013 at 16:25
• 76 Putting the definition in the condition tightens the scope so that you don't accidentally refer to derived on the next line after the if-statement. It's the same reason we use for (int i = 0... instead of int i; for (i = 0; ... . –  Adrian McCarthy Commented Jul 16, 2013 at 16:36
• 62 @JamesKanze - Others find it increases readability and maintainability, partly by minimizing the scope of the variable. "To avoid accidental misuse of a variable, it is usually a good idea to introduce the variable into the smallest scope possible. In particular, it is usually best to delay the definition of a variable until one can give it an initial value ... One of the most elegant applications of these two principles is to declare a variable in a conditional." -- Stroustrup, "The C++ Programming Language." –  Andy Thomas Commented Jul 16, 2013 at 16:40
• 13 @James: Nobody in my team has had a problem either reading or maintaining the code, in the ten years our codebase has taken this approach. –  Lightness Races in Orbit Commented Jul 16, 2013 at 17:42
• 15 Funny thing about the scope of the variable when putting a definition in the condition is that the variable is also accessible in the else -clause as well. if (T t = foo()) { dosomething(t); } else { dosomethingelse(t); } –  dalle Commented Jul 18, 2013 at 8:57

Here is some history on the syntax in question.

In classical C, error handling was frequently done by writing something like:

Or, whenever there was a function call that might return a null pointer, the idiom was used the other way round:

However, this syntax is dangerously close to

which is why many people consider the assignment inside a condition bad style, and compilers started to warn about it (at least with -Wall ). Some compilers allow avoiding this warning by adding an extra set of parentheses:

However, this is ugly and somewhat of a hack, so it's better avoid writing such code.

Then C99 came around, allowing you to mix definitions and statements, so many developers would frequently write something like

which does feel awkward. This is why the newest standard allows definitions inside conditions, to provide a short, elegant way to do this:

There isn't any danger in this statement anymore. You explicitly give the variable a type, obviously wanting it to be initialized. It also avoids the extra line to define the variable, which is nice. But most importantly, the compiler can now easily catch this sort of bug:

Without the variable definition inside the if statement, this condition would not be detectable.

To make a long answer short: The syntax in you question is the product of old C's simplicity and power, but it is evil, so compilers can warn about it. Since it is also a very useful way to express a common problem, there is now a very concise, bug robust way to achieve the same behavior. And there are a lot of good, possible uses for it.

• 1 But adding extra parenthesis is not "bug robust": approxion.com/a-gcc-compiler-mistake The MISRA-compliant code if ((a == b) && (c = d)) won't generate a warning or error because of GCC's "feature". Instead of "bug robust" it's perniciously buggy , You think using -Wall -Werror protects you from such bugs, but it actually doesn't . –  Andrew Henle Commented Jun 6, 2021 at 12:12
• 2 @AndrewHenle Well, that part about assignment in extra brackets was only to illustrate what has been done many times in real existing code. Of course , the extra parentheses are only a hack. Of course , they look ugly. Of course , this is just an extra reason to prefer the C++ variable declaration over a C assignment in an if() statement. You may question the sensibility of GCC's warning behavior, but that has no impact on my answer at all. –  cmaster - reinstate monica Commented Jun 6, 2021 at 13:16
• 1 The issue isn't with your answer - I think it's about the best possible factual discussion of the history of the "assignment in an if-statement" style came about. The problem is your answer was referred by someone who utterly missed your characterization of GCC's hack and actually used your answer as a defense of that hack. I was pointing out how GCC's hack actually opens the door to even more subtle bugs when more complex code is involved. That evil aspect of the GCC "extra parentheses" hack seems to be utterly missed by proponents of cramming assignments into if statements. –  Andrew Henle Commented Jun 6, 2021 at 16:12
• 3 @AndrewHenle Thanks for the explanation. It gets me thinking that it might be beneficial to point out that this is a hack, and that I discourage using it. –  cmaster - reinstate monica Commented Jun 6, 2021 at 18:44

The assignment operator returns the value of the assigned value . So, I might use it in a situation like this:

I assign x to be the value returned by getMyNumber and I check if it's not zero.

Avoid doing that. I gave you an example just to help you understand this.

To avoid such bugs up to some extent, one should write the if condition as if(NULL == ptr) instead of if (ptr == NULL) . Because when you misspell the equality check operator == as operator = , the compiler will throw an lvalue error with if (NULL = ptr) , but if (res = NULL) passed by the compiler (which is not what you mean) and remain a bug in code for runtime.

One should also read Criticism regarding this kind of code.

• 14 I want to learn/improve myself, please mention why you downvote. –  Maroun Commented Jul 16, 2013 at 16:16
• 2 I frequently use if(fp = fopen("file", "w")){ // file not open} else{ // file processing } –  Grijesh Chauhan Commented Jul 16, 2013 at 19:00
• 18 Reversing the operands of an equality comparison, such as writing (NULL == ptr) rather than (ptr == NULL) , is controversial. Personally, I hate it; I find it jarring, and I have to mentally re-reverse it to understand it. (Others obviously don't have that issue). The practice is referred to as "Yoda conditions" . Most compilers can be persuaded to warn about assignments in conditions anyway. –  Keith Thompson Commented Jul 16, 2013 at 19:30
• 1 I think its nice to know the trick! I added as an information, Some people may like it. That is why its just a suggestion. –  Grijesh Chauhan Commented Jul 16, 2013 at 20:01
• 1 @LilianA.Moraru For some it is helpful. That's why it's a suggestion, if you don't like it you don't have to use it. –  Maroun Commented Oct 17, 2017 at 8:36

why doesn't the compiler throw a warning

Some compilers will generate warnings for suspicious assignments in a conditional expression, though you usually have to enable the warning explicitly.

For example, in Visual C++ , you have to enable C4706 (or level 4 warnings in general). I generally turn on as many warnings as I can and make the code more explicit in order to avoid false positives. For example, if I really wanted to do this:

Then I'd write it as:

The compiler sees the explicit test and assumes that the assignment was intentional, so you don't get a false positive warning here.

The only drawback with this approach is that you can't use it when the variable is declared in the condition. That is, you cannot rewrite:

Syntactically, that doesn't work. So you either have to disable the warning, or compromise on how tightly you scope x .

C++17 added the ability to have an init-statement in the condition for an if statement ( p0305r1 ), which solves this problem nicely (for kind of comparison, not just != 0 ).

Furthermore, if you want, you can limit the scope of x to just the if statement:

• The explicit comparison if((x = Foo()) != 0) is unnecessary: adding an extra pair of parentheses if((x = Foo())) will silence the warning just as well. Also, there is a big difference between if(x = Foo()) and if(int x = Foo()) , the later clearly states that you want to do an initialization, not a comparison, so no compiler in their right mind would want to throw a warning on this. –  cmaster - reinstate monica Commented Aug 26, 2013 at 17:35
• 2 To be fair, you don't have to compromise how tightly you scope x if you are willing to surround your block with extra braces. But I wager this is not usually worth it. –  Thomas Eding Commented Aug 26, 2013 at 18:30
• 2 @cmaster: Explicit comparison is necessary if you want to check something other than != 0 . Explicit comparison is also clearer than an extra set of parentheses. –  Adrian McCarthy Commented Aug 26, 2013 at 20:33
• 1 @AdrianMcCarthy: Explicit comparison also requires that extra set of parentheses (due to operator precedence). So the addition of ` != 0` is always just extra code. Of course, you are right that explicit comparison can compare to anything. If you are comparing against 0, however, I heartily disagree with you: This is such a common idiom that I expect the shorter version in that case, so that the extra ` != 0` has the effect of a small pothole to me... –  cmaster - reinstate monica Commented Aug 26, 2013 at 20:53
• 1 @cmaster: That may be the case for you. But other programmers may be confused and think the extra parentheses are superfluous. They could delete them (which might not bother the compiler if they haven't enabled the same warning). Then someone will come along and think the assignment was supposed to be == , and now you've got two bugs. The explicit comparison makes it obvious clear why the extra parentheses are there and, more importantly, that the assignment was not a typo. –  Adrian McCarthy Commented Mar 27, 2019 at 12:11

In C++17 , one can use:

Similar to a for loop iterator initializer.

Here is an example:

It depends on whether you want to write clean code or not. When C was first being developed, the importance of clean code wasn't fully recognized, and compilers were very simplistic: using nested assignment like this could often result in faster code. Today, I can't think of any case where a good programmer would do it. It just makes the code less readable and more difficult to maintain.

• 1 I agree that it's less readable but only if the assignment is the only thing in the if statement. If it's something like if ((x = function()) > 0) then I think that's perfectly fine. –  ashishduh Commented Mar 24, 2014 at 19:29
• 2 @user1199931 Not really. If you're scanning the code to get a general understanding of it, you'll see the if and continue, and miss the fact that there is a change of state. There are exceptions ( for , but the keyword itself says that it is both looping and managing the loop state), but in general, a line of code should do one, and only one thing. If it controls flow, it shouldn't modify state. –  James Kanze Commented Mar 26, 2014 at 13:41
• 3 "Clean code" is a very subjective term, unfortunately. –  Michael Warner Commented Jan 11, 2016 at 22:01

Suppose you want to check several conditions in a single if , and if any one of the conditions is true, you'd like to generate an error message. If you want to include in your error message which specific condition caused the error, you could do the following:

So if the second condition is the one that evaluates to true, e will be equal to "cd". This is due to the short-circuit behaviour of || which is mandated by the standard (unless overloaded). See this answer for more details on short-circuiting.

• Interesting, but isn't it also for showing cleverness? –  Wolf Commented Apr 23, 2019 at 9:50
• Using const char* e; instead of std::string e; would make it faster, but the similarity of the lines seems to ask for a loop over {"ab", "cd", "ef"}; . –  Wolf Commented Oct 1, 2021 at 10:15

Doing assignment in an if is a fairly common thing, though it's also common that people do it by accident.

The usual pattern is:

The anti-pattern is where you're mistakenly assigning to things:

You can avoid this to a degree by putting your constants or const values first, so your compiler will throw an error:

= vs. == is something you'll need to develop an eye for. I usually put whitespace around the operator so it's more obvious which operation is being performed, as longname=longername looks a lot like longname==longername at a glance, but = and == on their own are obviously different.

• 10 They're both anti patterns. And as for if ( 1 == x ) , it's not the natural way of expressing the test, and any compiler worth its salt will warn for if ( x = 1 ) , so there's really no reason for being ugly here either. –  James Kanze Commented Jul 16, 2013 at 16:10
• 1 The 1 == x pattern, anti or not, comes from Code Complete so you'll see it fairly often. It's a bit ugly, but might be a reasonable requirement for people that have a problem getting this right, serving as training wheels. –  tadman Commented Jul 16, 2013 at 16:17
• 3 @tadman The way to teach people is by annoying them with warnings about this typo, not to switch to yoda conditions. –  stefan Commented Jul 16, 2013 at 16:18
• 2 @stefan Especially as most compilers have an option to turn warnings into errors. –  James Kanze Commented Jul 16, 2013 at 16:21
• @tadman: And reasonable compiler warnings catch more instances of this mistake than Yoda conditions do. And Yoda conditions only help when you remember to use them. –  Adrian McCarthy Commented Jul 16, 2013 at 16:22

a quite common case. use

this kind of typo will cause compile error

Not the answer you're looking for? Browse other questions tagged c++ if-statement or ask your own question .

• The Overflow Blog
• The evolution of full stack engineers
• One of the best ways to get value for AI coding tools: generating tests
• Featured on Meta
• Bringing clarity to status tag usage on meta sites
• Join Stack Overflow’s CEO and me for the first Stack IRL Community Event in...
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation
• What does a new user need in a homepage experience on Stack Overflow?

Hot Network Questions

• Understanding the parabolic state of a quantum particle in the infinite square well
• Fantasy book about humans and gnomes entering one another's worlds
• A probably Fantasy middle-length fiction about a probable vampire during the Blitz
• Was using an older version of a legal card from a nonlegal set ever not legal?
• Getting lost on a Circular Track
• Why does each leg of my 240V outlet measure 125V to ground, but 217V across the hot wires?
• Can flood basalt eruptions start in historical timescales?
• Practice test paper answers all seem incorrect, but provider insists they are ... what am i missing?
• Wrong explanation for why "electron can't exist in the nucleus"?
• DFT warn: LUMO = HOMO
• Can someone confirm this observed bug for `bc`? `scale=0` has no effect!
• 4/4 time change to 6/8 time
• A journal has published an AI-generated article under my name. What to do?
• Does the Supremacy Clause allow states to retain abortion rights enshrined in each states' constitution?
• Why are some Cloudflare challenges CPU intensive?
• Why would the GPL be viral, while EUPL isn't, according to the EUPL authors?
• The pronoun in short yes/no answers to rhetorical tag-questions with the generic "you"
• Why doesn't SiLU suffer from a worse version of a "dying ReLU" problem?
• Can I land on the "EuroAirport Basel-Mulhouse-Freiburg" with a German National Visa as first destination (NON-EU Citizen)?
• Remove spaces from the 3rd line onwards in a file on linux
• How are you supposed to trust SSO popups in desktop and mobile applications?
• I want to be a observational astronomer, but have no idea where to start
• Consistency-proof of ZFC
• What are the intermediate semisimple groups of type A?