assignment to expression with array type struct

How to solve “Error: Assignment to expression with array type” in C?

In C programming, you might have encountered the “ Error: Assignment to expression with array type “. This error occurs when trying to assign a value to an already initialized  array , which can lead to unexpected behavior and program crashes. In this article, we will explore the root causes of this error and provide examples of how to avoid it in the future. We will also learn the basic concepts involving the array to have a deeper understanding of it in C. Let’s dive in!

What is “Error: Assignment to expression with array type”? What is the cause of it?

An array is a collection of elements of the same data type that are stored in contiguous memory locations. Each element in an array is accessed using an index number. However, when trying to assign a value to an entire array or attempting to assign an array to another array, you may encounter the “Error: Assignment to expression with array type”. This error occurs because arrays in C are not assignable types, meaning you cannot assign a value to an entire array using the assignment operator.

First example: String

Here is an example that may trigger the error:

In this example, we have declared a char array “name” of size 10 and initialized it with the string “John”. Then, we are trying to assign a new string “Mary” to the entire array. However, this is not allowed in C because arrays are not assignable types. As a result, the compiler will throw the “Error: Assignment to expression with array type”.

Initialization

When you declare a char array in C, you can initialize it with a string literal or by specifying each character separately. In our example, we initialized the char array “name” with the string literal “John” as follows:

This creates a char array of size 10 and initializes the first four elements with the characters ‘J’, ‘o’, ‘h’, and ‘n’, followed by a null terminator ‘\0’. It’s important to note that initializing the array in this way does not cause the “Error: Assignment to expression with array type”.

On the other hand, if you declare a char array without initializing it, you will need to assign values to each element of the array separately before you can use it. Failure to do so may lead to undefined behavior. Considering the following code snippet:

We declared a char array “name” of size 10 without initializing it. Then, we attempted to assign a new string “Mary” to the entire array, which will result in the error we are currently facing.

When you declare a char array in C, you need to specify its size. The size determines the maximum number of characters the array can hold. In our example, we declared the char array “name” with a fixed size of 10, which can hold up to 9 characters plus a null terminator ‘\0’.

If you declare a char array without specifying its size, the compiler will automatically determine the size based on the number of characters in the string literal you use to initialize it. For instance:

This code creates a char array “name” with a size of 5, which is the number of characters in the string literal “John” plus a null terminator. It’s important to note that if you assign a string that is longer than the size of the array, you may encounter a buffer overflow.

Second example: Struct

We have known, from the first example, what is the cause of the error with string, after that, we dived into the definition of string, its properties, and the method on how to initialize it properly. Now, we can look at a more complex structure:

This struct “struct_type” contains an integer variable “id” and a character array variable “string” with a fixed size of 10. Now let’s create an instance of this struct and try to assign a value to the “string” variable as follows:

As expected, this will result in the same “Error: Assignment to expression with array type” that we encountered in the previous example. If we compare them together:

• The similarity between the two examples is that both involve assigning a value to an initialized array, which is not allowed in C.
• The main difference between the two examples is the scope and type of the variable being assigned. In the first example, we were dealing with a standalone char array, while in the second example, we are dealing with a char array that is a member of a struct. This means that we need to access the “string” variable through the struct “s1”.

So basically, different context, but the same problem. But before dealing with the big problem, we should learn, for this context, how to initialize a struct first. About methods, we can either declare and initialize a new struct variable in one line or initialize the members of an existing struct variable separately.

Take the example from before, to declare and initialize a new struct variable in one line, use the following syntax:

To initialize the members of an existing struct variable separately, you can do like this:

Both of these methods will initialize the “id” member to 1 and the “struct_name” member to “structname”. The first one is using a brace-enclosed initializer list to provide the initial values of the object, following the law of initialization. The second one is specifically using strcpy() function, which will be mentioned in the next section.

How to solve “Error: Assignment to expression with array type”?

Initialize the array type member during the declaration.

As we saw in the first examples, one way to avoid this error is to initialize the array type member during declaration. For example:

This approach works well if we know the value of the array type member at the time of declaration. This is also the basic method.

Use the strcpy() function

We have seen the use of this in the second example. Another way is to use the strcpy() function to copy a string to the array type member. For example:

Remember to add the string.h library to use the strcpy() function. I recommend going for this approach if we don’t know the value of the array type member at the time of declaration or if we need to copy a string to the member dynamically during runtime. Consider using strncpy() instead if you are not sure whether the destination string is large enough to hold the entire source string plus the null character.

Use pointers

We can also use pointers to avoid this error. Instead of assigning a value to the array type member, we can assign a pointer to the member and use malloc() to dynamically allocate memory for the member. Like the example below:

Before using malloc(), the stdlib.h library needs to be added. This approach is also working well for the struct type. In the next approach, we will talk about an ‘upgrade-version’ of this solution.

Use structures with flexible array members (FAMs)

If we are working with variable-length arrays, we can use structures with FAMs to avoid this error. FAMs allow us to declare an array type member without specifying its size, and then allocate memory for the member dynamically during runtime. For example:

The code is really easy to follow. It is a combination of the struct defined in the second example, and the use of pointers as the third solution. The only thing you need to pay attention to is the size of memory allocation to “s”. Because we didn’t specify the size of the “string” array, so at the allocating memory process, the specific size of the array(10) will need to be added.

This a small insight for anyone interested in this example. As many people know, the “sizeof” operator in C returns the size of the operand in bytes. So when calculating the size of the structure that it points to, we usually use sizeof(*), or in this case: sizeof(*s).

But what happens when the structure contains a flexible array member like in our example? Assume that sizeof(int) is 4 and sizeof(char) is 1, the output will be 4. You might think that sizeof(*s) would give the total size of the structure, including the flexible array member, but not exactly. While sizeof is expected to compute the size of its operand at runtime, it is actually a compile-time operator. So, when the compiler sees sizeof(*s), it only considers the fixed-size members of the structure and ignores the flexible array member. That’s why in our example, sizeof(*s) returns 4 and not 14.

How to avoid “Error: Assignment to expression with array type”?

Summarizing all the things we have discussed before, there are a few things you can do to avoid this error:

• Make sure you understand the basics of arrays, strings, and structures in C.
• Always initialize arrays and structures properly.
• Be careful when assigning values to arrays and structures.
• Consider using pointers instead of arrays in certain cases.

The “ Error: Assignment to expression with array type ” in C occurs when trying to assign a value to an already initialized  array . This error can also occur when attempting to assign a value to an array within a  struct . To avoid this error, we need to initialize arrays with a specific size, use the strcpy() function when copying strings, and properly initialize arrays within structures. Make sure to review the article many times to guarantee that you can understand the underlying concepts. That way you will be able to write more efficient and effective code in C. Have fun coding!

“Expected unqualified-id” error in C++ [Solved]

How to Solve does not name a type error in C++

cppreference.com

Array declaration.

Array is a type consisting of a contiguously allocated nonempty sequence of objects with a particular element type . The number of those objects (the array size) never changes during the array lifetime.

[ edit ] Syntax

In the declaration grammar of an array declaration, the type-specifier sequence designates the element type (which must be a complete object type), and the declarator has the form:

[ edit ] Explanation

There are several variations of array types: arrays of known constant size, variable-length arrays, and arrays of unknown size.

[ edit ] Arrays of constant known size

If expression in an array declarator is an integer constant expression with a value greater than zero and the element type is a type with a known constant size (that is, elements are not VLA) (since C99) , then the declarator declares an array of constant known size:

Arrays of constant known size can use array initializers to provide their initial values:

[ edit ] Arrays of unknown size

If expression in an array declarator is omitted, it declares an array of unknown size. Except in function parameter lists (where such arrays are transformed to pointers) and when an initializer is available, such type is an incomplete type (note that VLA of unspecified size, declared with * as the size, is a complete type) (since C99) :

[ edit ] Qualifiers

[ edit ] assignment.

Objects of array type are not modifiable lvalues , and although their address may be taken, they cannot appear on the left hand side of an assignment operator. However, structs with array members are modifiable lvalues and can be assigned:

[ edit ] Array to pointer conversion

Any lvalue expression of array type, when used in any context other than

• as the operand of the address-of operator
• as the operand of sizeof
• as the operand of typeof and typeof_unqual (since C23)
• as the string literal used for array initialization

undergoes an implicit conversion to the pointer to its first element. The result is not an lvalue.

If the array was declared register , the behavior of the program that attempts such conversion is undefined.

When an array type is used in a function parameter list, it is transformed to the corresponding pointer type: int f ( int a [ 2 ] ) and int f ( int * a ) declare the same function. Since the function's actual parameter type is pointer type, a function call with an array argument performs array-to-pointer conversion; the size of the argument array is not available to the called function and must be passed explicitly:

[ edit ] Multidimensional arrays

When the element type of an array is another array, it is said that the array is multidimensional:

Note that when array-to-pointer conversion is applied, a multidimensional array is converted to a pointer to its first element, e.g., pointer to the first row:

[ edit ] Notes

Zero-length array declarations are not allowed, even though some compilers offer them as extensions (typically as a pre-C99 implementation of flexible array members ).

If the size expression of a VLA has side effects, they are guaranteed to be produced except when it is a part of a sizeof expression whose result doesn't depend on it:

[ edit ] References

• C23 standard (ISO/IEC 9899:2023):
• 6.7.6.2 Array declarators (p: TBD)
• C17 standard (ISO/IEC 9899:2018):
• 6.7.6.2 Array declarators (p: 94-96)
• C11 standard (ISO/IEC 9899:2011):
• 6.7.6.2 Array declarators (p: 130-132)
• C99 standard (ISO/IEC 9899:1999):
• 6.7.5.2 Array declarators (p: 116-118)
• C89/C90 standard (ISO/IEC 9899:1990):
• 3.5.4.2 Array declarators

[ edit ] See also

• 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 16 January 2024, at 16:08.
• This page has been accessed 250,901 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Understanding Assignment to Expression with Array Type – A Comprehensive Guide

Introduction.

Overview of assignment to expression with array type

Importance of understanding this concept

The assignment to expression with array type is a fundamental concept in programming languages, especially those that support arrays. It refers to the process of assigning values to an array expression, which allows for the manipulation and control of array data. Understanding this concept is crucial for developers as it forms the basis for working with arrays effectively, ensuring the correct assignment of values.

Basic Concepts

Definition of array type

Understanding assignment to expression

Differences between assignment and expression

Importance of array type in programming languages

To comprehend assignment to expression with array type, it is essential to have a clear understanding of the array type itself. An array is a data structure that allows for the storage of multiple values of the same data type under a single variable name. In programming languages, the assignment operator (=) is used to assign values to variables. However, when it comes to arrays, the assignment to expression is slightly different. It involves assigning values to specific elements within an array. It is crucial to differentiate between assignment and expression. While assignment refers to the process of assigning values, an expression represents a value or combination of values that can be evaluated. The array type holds significance in programming languages as it provides a convenient way to organize and manipulate large amounts of data efficiently. Arrays enable developers to access and modify individual elements, making them indispensable in various applications.

Syntax and Usage

Syntax of assignment to expression with array type

Examples of common usage scenarios

Potential pitfalls and best practices

When working with assignment to expression with array type, it is essential to understand the syntax and usage associated with it. The syntax typically involves specifying the array name, followed by the index of the element being assigned, and then the value to be assigned. Let’s consider an example in a programming language like JavaScript:

This syntax allows for the assignment of a value to a specific element within the array. There are numerous common usage scenarios for assignment to expression with array type. For instance, it can be used to populate an array with initial values, update specific elements based on certain conditions, or retrieve values from arrays to perform calculations. However, there are some potential pitfalls that developers should be aware of. One common pitfall is accessing elements beyond the array’s bounds, which can result in unexpected behavior or memory allocation issues. It is important to thoroughly test and validate array index values to avoid such pitfalls. By following best practices, developers can ensure the efficient and effective usage of assignment to expression with array type. These best practices include properly initializing arrays before assigning values, validating index values to prevent out-of-bounds errors, and using descriptive variable names to improve code readability.

Understanding the Mechanics

How array elements are assigned to expressions

Handling of multidimensional arrays

Implications of assignment to expression with array type

Performance considerations

To comprehend assignment to expression with array type fully, it is crucial to understand the underlying mechanics involved in assigning values to array elements. When an array element is assigned to an expression, the value of the expression is stored in the specified array element. This allows for manipulation and modification of array data, as specific elements can be updated individually while leaving the remaining elements unchanged. In the case of multidimensional arrays, the assignment to expression with array type becomes slightly more complex. Multidimensional arrays contain multiple dimensions or arrays within arrays. In such cases, each dimension is accessed individually using separate indices to assign values to specific elements. The assignment to expression with array type has various implications in programming. It enables developers to work with large datasets efficiently and provides flexibility in manipulating array elements based on specific requirements. However, it also requires careful handling to avoid errors and unexpected behavior. It is essential to consider performance considerations when using assignment to expression with array type, especially when dealing with large arrays or frequent updates. In such cases, optimizing the code by minimizing unnecessary assignments or using more efficient algorithms can enhance performance.

Examples and Case Studies

Example code snippets demonstrating assignment to expression with array type

Real-world case studies showcasing practical applications

Analysis of complex scenarios and troubleshooting tips

Let’s explore some examples to illustrate how assignment to expression with array type works in practice. Example 1: Populating an array with initial values

In this example, an array called “numbers” is assigned with initial values using assignment to expression with array type. Case Study: Sales Dashboard In a real-world scenario, consider a sales dashboard that tracks the performance of sales representatives. The sales data can be stored in an array, allowing for assignment to expression with array type. By updating specific elements of the array based on sales figures, the dashboard can display real-time sales data and provide insights into sales performance. When faced with complex scenarios or troubleshooting issues related to assignment to expression with array type, the following tips can be helpful: – Validate all array indices to ensure they are within the bounds of the array. – Use appropriate error handling mechanisms, such as try-catch blocks, to handle any potential errors. – Utilize debugging tools and techniques to identify and resolve issues, such as console logging or using a debugger.

Best Practices and Tips

Guidelines for efficient and effective use of assignment to expression with array type

Debugging techniques for common issues

Performance optimization tips

To ensure efficient and effective use of assignment to expression with array type, developers should adhere to certain best practices and follow specific guidelines: – Always initialize arrays before assigning values to them to prevent unexpected behavior. – Validate array indices to avoid accessing elements beyond the array’s bounds. – Use descriptive variable names, making the code more readable and maintainable. – Employ proper error handling mechanisms to catch and handle any potential errors. When troubleshooting issues related to assignment to expression with array type, developers can employ debugging techniques such as console logging or using a debugger. These techniques help identify and resolve issues, ensuring the correct assignment of values to array elements. To optimize performance when working with assignment to expression with array type, developers can consider the following tips: – Minimize unnecessary assignments to improve code efficiency. – Use algorithms and data structures that provide better performance for specific use cases. – Leverage built-in language features or libraries designed for working with arrays efficiently.

Summary of key points covered in the blog post

Importance of understanding assignment to expression with array type in programming

Encouragement to further explore and practice this concept

In conclusion, assignment to expression with array type is a crucial concept in programming languages that support arrays. It involves assigning values to specific elements within an array, allowing for efficient manipulation and control of array data. Throughout this blog post, we explored the basic concepts of array types, the syntax and usage of assignment to expression with array type, and the mechanics involved in assigning values. We also discussed real-world case studies, best practices, and performance considerations. Understanding assignment to expression with array type is essential for developers as it forms the foundation for effectively working with arrays. It empowers developers to organize and manipulate large amounts of data efficiently, providing flexibility in various application domains. We encourage further exploration and practice of this concept to deepen your understanding and proficiency in working with arrays. By mastering assignment to expression with array type, you can unlock the full potential of arrays in your programming endeavors.

Related posts:

• Mastering Arrays in Visual Basic.NET – A Comprehensive Guide
• Mastering Array Length – A Comprehensive Guide to Understanding and Implementing Array Length in Programming
• Mastering JavaScript – Exploring the Power of the Array Constructor
• Mastering the Move Assignment Operator – A Comprehensive Guide and Best Practices
• Mastering Arrays in Visual Basic.NET – A Comprehensive Guide and Examples

Next: Unions , Previous: Overlaying Structures , Up: Structures   [ Contents ][ Index ]

15.13 Structure Assignment

Assignment operating on a structure type copies the structure. The left and right operands must have the same type. Here is an example:

Notionally, assignment on a structure type works by copying each of the fields. Thus, if any of the fields has the const qualifier, that structure type does not allow assignment:

See Assignment Expressions .

When a structure type has a field which is an array, as here,

structure assigment such as r1 = r2 copies array fields’ contents just as it copies all the other fields.

This is the only way in C that you can operate on the whole contents of a array with one operation: when the array is contained in a struct . You can’t copy the contents of the data field as an array, because

would convert the array objects (as always) to pointers to the zeroth elements of the arrays (of type struct record * ), and the assignment would be invalid because the left operand is not an lvalue.

How to Fix Error: Assignment To Expression With Array Type

This error shows the error as not assignable due to the value associated with the string; or the value is not feasible in C programming language. 

In order to solve this, you have to use a normal stcpy() function to modify the value.

However, there are other  possible ways to fix this issue.

Causes of the error

Here are few reasons for error: assignment to expression with array type: 

#1. Using unassignable array type

You are using an array type that is not assignable, or one that is trying to change the constant value in the program

If you are trying to use an unsignable array in the program, here’s what you will see:

This is because s1.name is an array type that is unassignable. Therefore, the output contains an error.

#2. Error occurs because block of memory is below 60 chars

The error also appears if the block of memory is below 60 chars. The data should always  be a block of memory that fits 60 chars.

In the example above, “data s1” is responsible for allocating the memory on the stack. Assignments then copy the number, and fails because the s1.name is the start of  a struct 64 bytes long which can be detected by a compiler, also Ogechukwu is 6 bytes long char due to the trailing \0 in the C strings. So , assigning a pointer to a string into a string is impossible, and this expression error occurs.

Example: 

The output will be thus :

#3. Not filling structure with pointers

If a programmer does not define a structure which points towards char arrays of any length, an expression error occurs, however  If the programmer uses a  defined structure field, they also have to set pointers in it too. Example of when a program does not have a defined struct which points towards a char.

#4. There is a syntax error

If a Programmers uses a function in an incorrect order, or syntax.also if the programer typed in the wrong expression within the syntax.

example of a wrong syntax, where using “-” is invalid:

#5. You directly assigned a value to a string

The C programming language does not allow  users to assign the value to a string directly. So you cant directly assign value to a string, ifthey do there will receive an expression error. 

Example of such:

#6. Changing the constant value

As a programmer, if you are trying to change a constant value, you will encounter the expression error. an initialized string , such as “char sample[19]; is a constant pointer. Which  means the user can change the value of the thing that the pointer is pointing to, but cannot change the value of the pointer itself. When the user tries to change the pointer, they are actually trying to change the string’s address, causing the error.

The output gives the programmer two independent addresses. The first address is the address of s1.name while the second address is that of Ogechukwu. So a programmer cannot change s1.name address to Ogechukwu address because it is a constant.

How to fix “error: assignment to expression with array type” error?

The following will help you fix this error:

#1. Use an assignable array type

Programmers are advised to use the array type that is assignable by the arrays because an unassignable array will not be recognized by the program causing the error.  To avoid this error, make sure the correct array is being used.

Check out this example:

#2. Use a block of memory that fits 60 chars

Use the struct function to define a struct pointing to char arrays of any lenght.  This means the user does not have to worry about the length of the block of memory. Even if the length cis  below 60 chars, the program will still run smoothly.

But if you are not using the struct function, take care of the char length and that the memory block should fit 60 chars and not below to avoid this error.  

#3. Fill the structure with pointers

If the structure is not filled with pointers, you will experience this error. So ensure you fill the struct with pointers that point to char arrays.

Keep in mind that the ints and pointers can have different sizes. Example 

This example, the struct has been filled with pointers.

#4. Use the correct syntax

Double check and ensure you are using the right syntax before coding.if you are confused about the right syntax, then consult Google to know the right one.

Example 

#5. Use Strcpy() function to modify

In order to modify the pointer or overall program, it is advisable to use  the strcpy() function. This function will modify the value as well because directly assigning the value to a string is impossible in a C programming language. usin g this function  helps the user  get rid of assignable errors. Example 

Strcpy(s1.name, “New_Name”);

#6. Copy an array using Memcpy 

In order to eliminate this error,a programmer can use the memcpy function to copy an array into a string and prevent  errors.

#7. Copy into the array using  Strcpy() 

Also you can copy into the array using strcpy() because of the modifiable lvalue. A modifiable lvalue is an lvalue that  has no array type. So programmers have to  use strcpy() to copy data into an array. 

Follow these guide properly and get rid of “error: assignment to expression with array type”.

Written by:

View all posts

# Related Articles

How to start a spotify jam session with friends, how to add, remove, and delete samsung account from your android phone, how to add columns permanently to all folders in windows 10 file explorer.

Terecle  stands exclusively unparalleled in actualizing the techie in you. We review and recommend products and services, and also help you fix them when broken.

• Editorial Statement
• Privacy Policy
• Cookie Disclosure
• Advertise with us

© 2021-2024 HAUYNE LLC., ALL RIGHTS RESERVED

Terecle is part of Hauyne publishing family.  The display of third-party trademarks and trade names on this site does not necessarily indicate any affiliation or the endorsement of Terecle .

Type above and press Enter to search. Press Esc to cancel.

404 Not found

404 Not found

404 Not found

404 Not found

404 Not found

Can't access an array-type member of a structure?

As a part of learning/exercise process, I attemptd to assign a string to an array-type member of a structure using dot (.) operator of the following sketch; but, the relevant line is not compiled. Would appreciate to know the reason which is not clear to me from the error message.

The problem has nothing to do with the struct. You cannot change an array in the way that you tried. Use this instead

@UKHeliBob Your code of Post-2 works well.

Then, why does the following assignment instruction work when accessing an item of the name[ ] array?

Because you are then only accessing a single item in the array, whereas in your code you are trying to access the whole array at once

As I said, the fact that the array is in a struct is not relevant

In the following codes, I can access the whole array and also an item of the array.

The concern to me is that -- while the following code works:

Then the under-mentioned code should work (logically)?

The struct is irrelevant in this context - you can't assign a C string like that.

C-style arrays have weird quirks, they don't obey the usual value semantics of the language.

To get value semantics, either use a C++ array ( std::array ), or wrap it in a struct:

Otherwise you'll have to use memcpy or strcpy or some equivalent element-by-element copy function.

Edit : unfortunately, the example triggers a bug in previous versions of GCC: c++ - Initializing std::array<char,x> member in constructor using string literal. GCC bug? - Stack Overflow It works fine in Clang and MSVC and the latest version of GCC, though.

As AWOL and I have said, the struct is irrelevant

as an example of what you can do, but they are not equivalent because date is not an array, it is a single int whereas name is an array

Given an array of chars

then you simply can't do

Interestingly, the following codes work though they don't meet my demand:

Another equivalent way using structure pointer.

That's an initialisation, not an assignment.

1. Variable declaration:

2. Variable creation:

3. Variable initialization: I think that it is same as Step-2.

4. Variable assigment: I think that it is same as Step-2 as there is an assignment operator.

Would be glad to know your definitions with examples.

Could you please correct the misleading comments in the code snippets in points 1 and 2?

https://www.google.com/search?q=c%2B%2B+define+declare+initialize

brings you there:

https://stackoverflow.com/questions/23345554/the-differences-between-initialize-define-declare-a-variable

if you use pointers, that seems to be perfectly doable (though not sure how 'safe' that is!)

I assume that you ignored the compiler output such as

This is what I know from literature that "memory space is not allocated" when a variable is declared and not defined. Variable creation refers to assigning a value to it and this is the time when memory space is allocated for that variable/identifier.

Well, my definition would be irrelevant, the standard is the only authority when it comes to these things.

First off, declarations can be definitions. If you really want the details, read [basic.def] in the C++ standard. I'll quote the highlights:

A declaration may introduce one or more names into a translation unit or redeclare names introduced by previous declarations. If so, the declaration specifies the interpretation and semantic properties of these names.

A declaration is said to be a definition of each entity that it defines. [Example 1: the following are definitions int a; // defines a int f(int x) { return x+a; } // defines f and defines x whereas these are just declarations extern int a; // declares a int f(int); // declares f — end example]

Assignment is pretty straightforward [expr.ass] :

In simple assignment (=), the object referred to by the left operand is modified by replacing its value with the result of the right operand. If the right operand is an expression, it is implicitly converted to the cv-unqualified type of the left operand.

Initialization is much more complicated, so I'll refer you to [dcl.init] and give some examples:

What does that mean? What literature? All variable declarations have a corresponding definition somewhere, so it doesn't make a whole lot of sense to say that declaration does not cause allocation.

"Variable creation" is not a term that I am familiar with.

Using C-style casts to make warnings go away is a terrible idea. See https://en.cppreference.com/w/cpp/language/explicit_cast :

When the C-style cast expression is encountered, the compiler attempts to interpret it as the following cast expressions, in this order: a) const_cast< new-type >( expression ) ; b) static_cast< new-type >( expression ) , with extensions: pointer or reference to a derived class is additionally allowed to be cast to pointer or reference to unambiguous base class (and vice versa) even if the base class is inaccessible (that is, this cast ignores the private inheritance specifier). Same applies to casting pointer to member to pointer to member of unambiguous non-virtual base; c) static_cast (with extensions) followed by const_cast; d) reinterpret_cast< new-type >( expression ) ; e) reinterpret_cast followed by const_cast. The first choice that satisfies the requirements of the respective cast operator is selected, even if it cannot be compiled (see example).

In other words: it can perform pretty much any nonsensical cast you can imagine, without any type checking by the compiler. The resulting reinterpret_cast is almost always invalid, see reinterpret_cast conversion - cppreference.com . A C-style cast can also cast away const , which is what you're doing here, which is a recipe for disaster, because now the compiler can no longer check whether the variables that you're writing to are actually writable (which would be undefined behavior).

In short, avoid the use of C-style casts , especially for pointers, and never use it to quickly work around a compiler error or warning .

The correct solution in this case is to use an immutable pointer (which is the right thing to do to point to immutable string literals):

If you absolutely must store a string literal in a non-const pointer, use an explicit const_cast<char *>("lit") , then the readers of your code can at least see that you're doing something fishy. If you then later use that pointer to write to the string literal (with absolutely no way for the compiler to check), it's your own fault when things come crashing down at runtime.

Then why does the "Introduction to C Programming" chapter of a textbook say -- A declared variable in a program is defined either by the user or by the program.

In the following program, I have declared a variable (unsigned int x;) which has been defined (value assignment) by the program (code).

Related Topics