incompatible types in assignment c

• Search forums
• C Programming

incompatible types in assignment

• Thread starter Brian Stubblefield
• Start date May 25, 2004

Brian Stubblefield

• May 25, 2004

Dear clc members, I am new to C and am posting several messages concerning a large C program that I am debugging. I am encountering a "incompatible types in assignment" warning for the following code during the compile stage: #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <string.h> int main(void) { /* removed code */ short int n = 10; char key[n][6]; short int i = { 0}; for(i = 1; i <= n; i++) { key = ' '; /* incompatible types in assignment */ { /* removed code */ } If there is a similar posting that provides the answer(s), please point me in the direction. I really do not know what look for in my search. Any help is greatly appreciated. Thank you, Brian  

Brian Stubblefield said: key = ' '; /* incompatible types in assignment */ Click to expand...

Eric Sosman

Brian said: Dear clc members, I am new to C and am posting several messages concerning a large C program that I am debugging. I am encountering a "incompatible types in assignment" warning for the following code during the compile stage: #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <string.h> int main(void) { /* removed code */ short int n = 10; char key[n][6]; Click to expand...

short int i = { 0}; Click to expand...

for(i = 1; i <= n; i++) Click to expand...

{ key = ' '; /* incompatible types in assignment */ Click to expand...

{ /* removed code */ } If there is a similar posting that provides the answer(s), please point me in the direction. I really do not know what look for in my search. Any help is greatly appreciated. Click to expand...

Barry Schwarz

• May 26, 2004

statement is trying to assign a char constant to a char pointer. You can either use double quotes to change the constant to a C-style string or you Click to expand...

can explicitly reference key [0] which is what I assume you intended. Click to expand...

Martin Ambuhl

Brian said: Dear clc members, I am new to C and am posting several messages concerning a large C program that I am debugging. I am encountering a "incompatible types in assignment" warning for the following code during the compile stage: #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <string.h> Click to expand...

int main(void) { /* removed code */ short int n = 10; char key[n][6]; short int i = { 0}; Click to expand...

{ /* removed code */ } Click to expand...

Thank you all for your programming suggestions and advice. I have been able to resolve the warning messages.  

RoSsIaCrIiLoIA

• May 30, 2004

Dear clc members, I am new to C and am posting several messages concerning a large C program that I am debugging. I am encountering a "incompatible types in assignment" warning for the following code during the compile stage: #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <string.h> int main(void) { /* removed code */ short int n = 10; char key[n][6]; short int i = { 0}; Click to expand...

Michael Fyles

RoSsIaCrIiLoIA said: #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <string.h> int main(void) { /* removed code */ short int n = 10; char key[n][6]; short int i = { 0}; Click to expand...

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Similar Threads

Members online, forum statistics, latest threads.

• Started by DMUK_Beginner
• Yesterday at 2:46 PM
• Started by treekmostly22
• Yesterday at 12:22 PM
• Friday at 7:58 AM
• Started by RGIANNETTI
• Thursday at 7:13 PM
• Thursday at 7:10 PM
• Started by Tobi1987
• Thursday at 6:34 AM
• Started by Mercury_Dev
• Thursday at 5:55 AM
• Started by timo
• Wednesday at 11:16 PM
• Started by Infinityhost
• Tuesday at 5:04 AM
• Tuesday at 5:00 AM

• C and C++ FAQ
• Mark Forums Read
• View Forum Leaders
• What's New?
• Get Started with C or C++
• C++ Tutorial
• Get the C++ Book
• All Tutorials
• Advanced Search

• General Programming Boards
• C Programming

C: Errors for Incompatible Types

• Getting started with C or C++ | C Tutorial | C++ Tutorial | C and C++ FAQ | Get a compiler | Fixes for common problems

Thread: C: Errors for Incompatible Types

Thread tools.

• Show Printable Version
• Email this Page…
• Subscribe to this Thread…
• View Profile
• View Forum Posts

I am writing a program in C. The following is an extract from my code: Code: enum coin_types { FIVE_CENTS=5, TEN_CENTS=10, TWENTY_CENTS=20, FIFTY_CENTS=50, ONE_DOLLAR=100, TWO_DOLLARS=200 }; struct coin { enum coin_types denomination; unsigned count; }; void * safe_malloc(size_t size) { void * mem = malloc(size); if(!mem) { perror("Failed to allocate memory"); abort(); } return mem; } FILE * coinsf = NULL; char line[600]; coinsf = fopen(coinsfile, "r"); /* Read in each line, while line is not null */ while(fgets(line, 600, coinsf) != NULL) { struct coin * new; line[strlen(line)-1] = 0; new = new_coins_data_line(line); } /* this function is in another file */ struct coin new_coins_data_line(char * line) { struct coin * newdata = NULL; newdata = (struct coin *) safe_malloc(sizeof(struct coin)); return newdata; } I'm getting the following errors: For: new = new_coins_data_line(line); "Incompatible types in assignment" For: return newdata; "Incompatible types in return" There seem to be problems with my variables and perhaps it is related to the type 'struct coin' which has an enumerated type within it. Please help me fix these errors. Thank you.

"struct coin" and "struct coin *" are two different types. Decide if you are returning a struct or a pointer to a struct. Code: struct coin new_coins_data_line(char * line) Tim S.

Last edited by stahta01; 10-23-2013 at 08:36 AM .

"...a computer is a stupid machine with the ability to do incredibly smart things, while computer programmers are smart people with the ability to do incredibly stupid things. They are,in short, a perfect match.." Bill Bryson

Additionally, you're not closing coinsf (or even checking that is was opened for that matter). As an aside, and not that it matters, let's also look at these lines (even though they're not the source of any error -- at the moment): Code: char line[600]; //... while(fgets(line, 600, coinsf) != NULL) //... I don't particularly like that 600. You could do something like #define MAXLINELEN 600 and use that in both your array declaration and in the fgets, but is there something better you could replace the 600 in the fgets with? As food for thought, consider what the value of foo might be after the following line is executed: Code: size_t foo = sizeof line; and also Code: size_t foo = sizeof line / sizeof line[0]; If you change the "element type" of line to, say, int line[600], what are the values of foo then?

Originally Posted by stahta01 "struct coin" and "struct coin *" are two different types. Decide if you are returning a struct or a pointer to a struct. Code: struct coin new_coins_data_line(char * line) Tim S. Thanks, I had completely overlooked the * in the function. I have changed it to: struct coin * new_coins_data_line(char * line) and that error is gone now. I still have an error for: new = new_coins_data_line(line); saying "incompatible types in assignment"

Do you know what a function prototype is? If yes, use one or correct the one you are using. Code: // Function Prototype must be before first use of function in the file. struct coin * new_coins_data_line(char * line);

Originally Posted by stahta01 Do you know what a function prototype is? If yes, use one or correct the one you are using. Code: // Function Prototype must be before first use of function in the file. struct coin * new_coins_data_line(char * line); This fixed it! Thank you!

• Private Messages
• Subscriptions
• Who's Online
• Search Forums
• Forums Home
• C++ Programming
• C# Programming
• Game Programming
• Networking/Device Communication
• Programming Book and Product Reviews
• Windows Programming
• Linux Programming
• General AI Programming
• Article Discussions
• General Discussions
• A Brief History of Cprogramming.com
• Contests Board
• Projects and Job Recruitment

• How to create a shared library on Linux with GCC - December 30, 2011
• Enum classes and nullptr in C++11 - November 27, 2011
• Learn about The Hash Table - November 20, 2011
• Rvalue References and Move Semantics in C++11 - November 13, 2011
• C and C++ for Java Programmers - November 5, 2011
• A Gentle Introduction to C++ IO Streams - October 10, 2011

Similar Threads

Incompatible types in assignment, incompatible types in assignment, incompatible pointer types, incompatible types huh.

• C and C++ Programming at Cprogramming.com
• Web Hosting
• Privacy Statement

HatchJS.com

Cracking the Shell of Mystery

Incompatible Pointer Types in C: A Guide to Fixing Errors

Incompatible Pointer Types in C

Pointers are a powerful tool in C, but they can also be a source of errors. One common error is using an incompatible pointer type. This can happen when you try to dereference a pointer of one type with a variable of another type. For example, you might try to dereference a pointer to a char with a variable of type int. This will cause a compiler error.

In this article, we’ll take a closer look at incompatible pointer types in C. We’ll discuss what they are, why they occur, and how to avoid them. We’ll also provide some examples of incompatible pointer types in action.

By the end of this article, you’ll have a good understanding of incompatible pointer types in C and how to avoid them.

What is an incompatible pointer type?

In C, a pointer is a variable that stores the address of another variable. When you declare a pointer, you must specify the type of the variable that it points to. For example, the following declaration creates a pointer to an integer:

The pointer `p` can be used to access the value of the integer variable that it points to. For example, the following code prints the value of the integer variable that `p` points to:

c printf(“The value of the integer variable is %d\n”, *p);

However, if you try to assign a pointer of one type to a variable of another type, you will get a compiler error. For example, the following code will generate a compiler error:

c int *p; char *q;

p = q; // Error: incompatible pointer types

This is because the pointer `p` is of type `int *`, and the pointer `q` is of type `char *`. These two types are incompatible, and you cannot assign a pointer of one type to a variable of another type.

An incompatible pointer type is a pointer that is not of the same type as the variable that it points to. This can happen for a variety of reasons, such as:

* **Casting a pointer to an incompatible type.** For example, the following code casts a pointer to an integer to a pointer to a character:

c int *p = 0; char *q = (char *)p; // Error: incompatible pointer types

* **Using a pointer to an array of one type to access an element of an array of another type.** For example, the following code uses a pointer to an array of integers to access an element of an array of characters:

c int arr1[] = {1, 2, 3}; char arr2[] = {‘a’, ‘b’, ‘c’};

int *p = arr1; char c = p[0]; // Error: incompatible pointer types

* **Using a pointer to a structure of one type to access a member of a structure of another type.** For example, the following code uses a pointer to a structure of type `struct point` to access a member of a structure of type `struct circle`:

c struct point { int x; int y; };

struct circle { struct point center; int radius; };

struct point *p = &circle.center; int x = p->x; // Error: incompatible pointer types

What are the causes of incompatible pointer types?

There are a number of reasons why you might get an incompatible pointer type error. Some of the most common causes include:

• Casting a pointer to an incompatible type. This is the most common cause of incompatible pointer type errors. When you cast a pointer to an incompatible type, you are essentially telling the compiler that you know what you are doing and that you are sure that the pointer is safe to use. However, in most cases, you are not aware of the potential dangers of casting a pointer to an incompatible type, and you are likely to make a mistake.
• Using a pointer to an array of one type to access an element of an array of another type. This is another common cause of incompatible pointer type errors. When you use a pointer to an array of one type to access an element of an array of another type, you are essentially telling the compiler that you know that the arrays are the same size and that you are sure that the pointer is safe to use. However, in most cases, you are not aware of the potential dangers of using a pointer to an array of one type to access an element of an array of another type, and you are likely to make a mistake.
• Using a pointer to a structure of one type to access a member of a structure of another type. This is another common cause of incompatible pointer type errors. When you use a pointer to a structure of one type to access a member of a structure of another type, you are essentially telling the compiler that you know that the structures are the same size and that you are sure that the pointer is safe to use. However, in most cases, you are not aware of the potential dangers of using a pointer to a structure of one type to access a member of a structure of another type, and you are likely to make a mistake.

Incompatible pointer types can

How to fix incompatible pointer types?

Incompatible pointer types occur when you try to assign a value of one pointer type to a variable of another pointer type. This can happen when you are trying to pass a pointer to a function that expects a different pointer type, or when you are trying to cast a pointer to a different type.

There are a few ways to fix incompatible pointer types.

• Use a type cast. A type cast is a way to explicitly convert a value of one type to another type. To use a type cast, you use the `(type)` syntax, where `type` is the type you want to convert the value to. For example, if you have a pointer to a `char` and you want to cast it to a pointer to a `int`, you would use the following syntax:

c int *intPtr = (int *)charPtr;

• Use a function pointer. A function pointer is a pointer to a function. You can use a function pointer to call a function with a different pointer type than the function’s declared type. To use a function pointer, you declare a variable of type `function_pointer`, and then assign the address of the function to the variable. For example, the following code declares a function pointer to a function that takes a `char` pointer and returns an `int`:

c typedef int (*MyFunction)(char *);

MyFunction myFunctionPtr = myFunction;

You can then call the function using the function pointer, like this:

c int result = myFunctionPtr(“Hello world!”);

• Use a struct. A struct is a collection of data elements that are grouped together. You can use a struct to store data of different types in a single variable. To use a struct, you declare a struct variable, and then add the data elements to the struct. For example, the following code declares a struct called `MyStruct` that has two data elements: a `char` pointer and an `int`:

c struct MyStruct { char *str; int num; };

struct MyStruct myStruct = {“Hello world!”, 10};

You can then access the data elements of the struct using the dot operator. For example, the following code prints the value of the `str` data element of the `myStruct` variable:

c printf(“str: %s\n”, myStruct.str);

Examples of incompatible pointer types

Here are some examples of incompatible pointer types:

• A pointer to a `char` cannot be assigned to a pointer to a `int`.
• A pointer to a function that takes a `char` pointer cannot be called with a pointer to an `int` pointer.
• A struct that has a `char` pointer cannot be assigned to a struct that has an `int` pointer.

In each of these cases, the compiler will generate an error when you try to compile the code.

Incompatible pointer types can be a source of errors in C programs. By understanding how to fix incompatible pointer types, you can avoid these errors and write more robust code.

Q: What is an incompatible pointer type error?

A: An incompatible pointer type error occurs when you try to use a pointer of one type with a variable of another type. For example, you might try to use a pointer to a char with a variable of type int. This error can occur for a number of reasons, but the most common is when you are trying to pass a pointer to a function that expects a different type of pointer.

Q: How can I fix an incompatible pointer type error?

A: There are a few ways to fix an incompatible pointer type error. The first is to make sure that the pointer and the variable are of the same type. If they are not, you can either cast the pointer to the correct type or change the type of the variable.

Another way to fix an incompatible pointer type error is to use a different function. If the function you are trying to call expects a different type of pointer, you can find a different function that accepts the type of pointer you have.

Finally, you can also try to use a pointer to a pointer. This means that you create a pointer to a variable of one type, and then you use that pointer to access a variable of another type. This can be a bit more complicated, but it can sometimes be the only way to fix an incompatible pointer type error.

Q: What are some common causes of incompatible pointer type errors?

A: There are a few common causes of incompatible pointer type errors. The first is when you are trying to pass a pointer to a function that expects a different type of pointer. For example, you might try to pass a pointer to a char to a function that expects a pointer to an int. This error can also occur when you are trying to access a member of a structure or class using a pointer of the wrong type.

Another common cause of incompatible pointer type errors is when you are trying to dereference a pointer that is not initialized. When you dereference a pointer, you are essentially accessing the memory that the pointer points to. If the pointer is not initialized, then you will not be able to access any memory, and you will get an incompatible pointer type error.

Finally, incompatible pointer type errors can also occur when you are trying to cast a pointer to a different type. When you cast a pointer, you are essentially changing the type of the pointer. This can be done to make the pointer compatible with a function or variable that expects a different type of pointer. However, if you cast a pointer to the wrong type, you will get an incompatible pointer type error.

Q: How can I prevent incompatible pointer type errors?

A: There are a few things you can do to prevent incompatible pointer type errors. The first is to make sure that you are using the correct types for your pointers and variables. If you are not sure what type to use, you can always check the documentation for the function or variable you are using.

Another way to prevent incompatible pointer type errors is to use a type-safe language. Type-safe languages prevent you from making mistakes with types, so you can be confident that your code will not have any incompatible pointer type errors.

Finally, you can also use a compiler that has a warning for incompatible pointer type errors. This warning will let you know if you are trying to use a pointer of one type with a variable of another type. This can help you to catch incompatible pointer type errors before they cause problems in your code.

Incompatible pointer types in C can be a common source of errors. This is because pointers are used to reference memory locations, and if the types of the pointers are not compatible, then the compiler will not be able to correctly track the memory locations that the pointers are referencing. This can lead to unexpected behavior and errors.

There are a few ways to avoid incompatible pointer types in C. One way is to use the correct type for the pointer. For example, if you are trying to reference a variable of type int, then you should use a pointer of type int*. Another way to avoid incompatible pointer types is to use the type cast operator. The type cast operator can be used to convert a pointer of one type to a pointer of another type. However, it is important to use the type cast operator correctly, as it can also lead to errors.

If you are unsure about whether or not two pointer types are compatible, then you can always check the compiler documentation. The compiler documentation will provide a list of the different types of pointers that are supported, and it will also provide information on how to use the type cast operator correctly.

By following these tips, you can help to avoid incompatible pointer types in C and ensure that your code is correct and runs without errors.

Author Profile

Latest entries

• December 26, 2023 Error Fixing User: Anonymous is not authorized to perform: execute-api:invoke on resource: How to fix this error
• December 26, 2023 How To Guides Valid Intents Must Be Provided for the Client: Why It’s Important and How to Do It
• December 26, 2023 Error Fixing How to Fix the The Root Filesystem Requires a Manual fsck Error
• December 26, 2023 Troubleshooting How to Fix the `sed unterminated s` Command

Similar Posts

Jest cannot find module: a guide to fixing this common error.

Jest Cannot Find Module: A Guide to Solving the Error Jest is a popular testing framework for JavaScript, but it can sometimes be difficult to use. One common error that Jest users encounter is “Jest cannot find module.” This error can occur for a variety of reasons, but it is usually caused by a problem…

ModuleNotFoundError: No module named ‘object_detection’

ModuleNotFoundError: No module named ‘object_detection’ If you’re a Python developer, you’ve probably encountered the dreaded ModuleNotFoundError at some point. This error occurs when you try to import a module that doesn’t exist, and it can be a real pain to troubleshoot. In this article, we’ll take a look at the ModuleNotFoundError in more detail, and…

How to Fix the `AttributeError: module ‘tabula’ has no attribute ‘read_pdf’` Error

AttributeError: module ‘tabula’ has no attribute ‘read_pdf’ If you’re getting this error message when trying to use the `tabula` Python library to read a PDF file, don’t worry, you’re not alone. This is a common error that can be easily fixed. In this article, I’ll explain what this error means and show you how to…

ValueError: Mountpoint must not already contain files

Have you ever tried to mount a filesystem on a directory that already contains files, only to get an error message like “ValueError: mountpoint must not already contain files”? If so, you’re not alone. This is a common problem that can be caused by a variety of factors, including: The directory you’re trying to mount…

How to Fix Failed Building Wheel for Yarl Error

Have you ever tried to build a wheel for Yarl and failed? If so, you’re not alone. Yarl is a powerful Python library for building HTTP clients and servers, but it can be tricky to get started with. In this article, we’ll walk you through the process of building a wheel for Yarl, step-by-step. We’ll…

Error:0A000152: SSL routines:::unsafe legacy renegotiation disabled

Error:0A000152: SSL routines:::unsafe legacy renegotiation disabled This error message is a common one that can occur when you’re trying to connect to a secure website. It means that the website’s server is configured to disable unsafe legacy renegotiation, which is a security feature that can be exploited by attackers. In this article, we’ll explain what…

"Incompatible types in assignment" error

I am a newby, I have just bought the Arduino board, but I am already fascinated! Because I do not know C/ C++ very well, I have a question about the following code. Why does it not work? The Compiler always says:

In function 'void setup()': error: incompatible types in assignment of 'void' to 'char [20]' In function 'void makeString(int)':

What did I make wrong? To be honest, I have tremendous problems with the variable types in C++!

Thank you very much for your help!!

You're trying to return something in a function that's defined as a void function.

It will compile. But it will not work. This is because by the time the bufferMakeString returns to your code that calls it, the variable is no longer active in RAM. You'll need to use a global buffer variable for this.

Hi AlphaBeta,

thank you for your quick reply! Now there is the following error:

In function 'void setup()': error: incompatible types in assignment of 'char*' to 'char [20]

[UNTESTED CODE]

char bufferMakeString[20]; void setup (){ Serial.begin(9600); char* string = makeString(233445); Serial.println(string); } void loop (){/ no loop /} char* makeString(int zahl) { itoa(zahl,bufferMakeString,10); return bufferMakeString; }

Yeah! Now it works! The LCD display shows the right number. Here is the actual code:

Another question: What happens, if I want to call makeString in the loop? May I always use

char* string = makeString(mode);

Or is this an illegal double definition of the variable?

It's perfectly legal, but you might as well use bufferMakeString .

Now an other question:

The important thing seems to be in "Subroutine: join3Strings". The result on the Display is "Mode 1", not "Mode 1 selected", as expected. Is there a logical problem in there? I just wanted to add these strings...

By the way: I think, the "join3String" function does work. If you call it with " char* lcdOutput = join3Strings("Mode ", "1", " selected");" it works properly.

Related topics

• Windows Programming
• UNIX/Linux Programming
• General C++ Programming
• error: incompatible types in assignment

  error: incompatible types in assignment