Cannot convert int to int ошибка

In this post I will be sharing how to fix incompatible types: int cannot be converted to int[] error. This error occurs at compile-time. As always, first, we will produce the error incompatible types: int cannot be converted to int[] error, before moving on to the solution.

Read Also: int to Integer in Java

[Fixed] incompatible types: int cannot be converted to int[] error

Example 1: Producing the error by assigning an int to a variable whose type is int[]

We can easily produce this error by assigning an int to a variable whose type is int[] as shown below:

public class IntCanNotBeConvertedToIntArray {
  static int[] array;
  static int count;

  public static void printArray(int size) {
      
      array = size;
      count = size;
      for (int i=0; i<count ; i++) {
          array[i] = i;
          System.out.print(array[i]+" ");
      }
  } 
  
  public static void main(String args[]) {
      printArray(13);
  }
}

Output:
IntCanNotBeConvertedToIntArray.java:7: error: incompatible types: int cannot be converted to int[]
            array = size;
                         ^
1 error

Explanation:

The cause of this error is by assigning an int to a variable whose type is int[]. In the above code, we need to initialize the array variable to an array, not to an integer. We can use a new keyword to initialize the array.

Solution:

In Java, we need to initialize the array variable not to an integer but an array. We can use the new keyword to solve this issue as shown below:

public class IntCanNotBeConvertedToIntArray {
  static int[] array;
  static int count;

  public static void printArray(int size) {
      
      array = new int[size];
      count = size;
      for (int i=0; i<count ; i++) {
          array[i] = i;
          System.out.print(array[i]+" ");
      }
  } 
  
  public static void main(String args[]) {
      printArray(13);
  }
}

Output:
0 1 2 3 4 5 6 7 8 9 10 11 12

Example 2: Producing the error by returning an int instead of int[] in the method

We can easily produce this error by returning an int instead of int[] as shown below:

public class IntCanNotBeConvertedToIntArray2 {
  static int[] array;

  public static int[] displayArray(int size) {
      array = new int[size];
      for (int i=0; i < size ; i++) {
          System.out.print(array[i]+" ");
      }    
     return size;
  } 
  
  public static void main(String args[]) {
      displayArray(3);
  }
}

Output:
IntCanNotBeConvertedToIntArray2.java:9: error: incompatible types: int cannot be converted to int[]
            return size;
                        ^
1 error

Explanation:

The cause of this error is by returning an int instead of int[] in the displayArray method.

Solution:

In the displayArray method, we need to return an int[] instead of int. Just replace size which is an int with an int[] array in the return type of the displayArray method as shown below:

public class IntCanNotBeConvertedToIntArray2 {
  static int[] array;

  public static int[] displayArray(int size) {
      array = new int[size];
      for (int i=0; i < size ; i++) {
          System.out.print(array[i]+" ");
      }     
      return array;
  } 
  
  public static void main(String args[]) {
      displayArray(3);
  }
}

Output:
0 0 0

That’s all for today. Please mention in the comments in case you are still facing the error incompatible types: int cannot be converted to int[] in Java.

1. 10-26-2007

   
   

   #1

   

   
   Registered User
   

   ---

   cannot convert ‘int’ to ‘int &’
   

   I got a small problem. I have an array class and it returns an index as a reference so it can be accessed or modified.

   Code:

   // Allows accessing and modifying the array's contents. 
   Datatype& operator[] (const int p_index) 
   {   
   	return m_array[p_index];    
   }

   This works fine. But now I want to add bound checking.

   I do this…

   Code:

   Datatype& operator[] (const int p_index) 
   {   
   	if ((p_index >= 0) && (p_index <= m_size))
   		return m_array[p_index];    
   }

   But the compiler complains about not all control paths return a value. So I do this…

   Code:

   Datatype& operator[] (const int p_index) 
   {    
   	if ((p_index >= 0) && (p_index <= m_size))
   	     return m_array[p_index];    
   	else
   	    return -1;  
   }

   I get an error saying I cannot convert an ‘int’ to ‘int &’. I want it to return something to indicate that it’s an invalid cell like a boolean somewhat. That way we can know if it was successful or not when trying to modify/access the array element. Got any idea how this can be done?

   ---

2. 10-26-2007

   
   

   #2

   

   
   Registered User
   

   ---

   You can’t return -1 or any other literal value. You could have a static member and return that, but it doesn’t really make much sense, especially since you are returning a non-const reference.

   I would do what vector does for operator[] and just define it as undefined behavior. Then you can return m_array[0] or m_array[m_size] just to suppress the compiler’s warning and actually do something.

   You could also do what vector does for at() and throw an exception. If you program or library uses exceptions then this might be the better and safer way to go. Simply throwing std::out_of_range should be fine.

   >> if ((p_index >= 0) && (p_index <= m_size))
   BTW, that should probably be p_index < m_size, not <=. And don’t forget to create a const version of the operator.

   ---

3. 10-26-2007

   
   

   #3

   

   
   Registered User
   

   ---

   I would do what vector does for operator[] and just define it as undefined behavior. Then you can return m_array[0] or m_array[m_size] just to suppress the compiler’s warning and actually do something.

   I’m not sure how vector does it. What do you mean as an undefined behavior? I don’t know if this would make much sense…

   Code:

   Datatype& operator[] (const int p_index) 
   {    
   	if ((p_index >= 0) && (p_index < m_size))
   		return m_array[p_index];  
   	else 
   		return m_array[m_size-1];
   }

   I guess a Get() function would work, but it would be convienent to have it in a [] operator too so I’m not getting two differnet behaviors.

   Last edited by philvaira; 10-26-2007 at 06:59 PM.

   ---

4. 10-27-2007

   
   

   #4

   

   
   Algorithm Dissector
   

   

   ---

   Originally Posted by philvaira
   

   I’m not sure how vector does it. What do you mean as an undefined behavior? I don’t know if this would make much sense…

   Code:

   Datatype& operator[] (const int p_index) 
   {    
   	if ((p_index >= 0) && (p_index < m_size))
   		return m_array[p_index];  
   	else 
   		return m_array[m_size-1];
   }

   I guess a Get() function would work, but it would be convienent to have it in a [] operator too so I’m not getting two differnet behaviors.

   That’s no good either. If the size is zero then you’re still accessing out of bounds.
   Best option is to change the if statement into an assert, and just always return m_array[p_index].
   Or you can use exceptions.
   Or if you really want to you can return a reference to a static Datatype.

   My homepage
   Advice: Take only as directed — If symptoms persist, please see your debugger

   Linus Torvalds: «But it clearly is the only right way. The fact that everybody else does it some other way only means that they are wrong»

   ---

5. 10-27-2007

   
   

   #5

   

   
   C++ Witch
   

   

   ---

   I’m not sure how vector does it. What do you mean as an undefined behavior? I don’t know if this would make much sense…

   In other words, do not do any bounds checking. It is up to the user of the class to ensure that only valid indices are used.

   Originally Posted by Bjarne Stroustrup (2000-10-14)

   I get maybe two dozen requests for help with some sort of programming or design problem every day. Most have more sense than to send me hundreds of lines of code. If they do, I ask them to find the smallest example that exhibits the problem and send me that. Mostly, they then find the error themselves. «Finding the smallest program that demonstrates the error» is a powerful debugging tool.

   Look up a C++ Reference and learn How To Ask Questions The Smart Way

   ---

Далее следует исходный пост — пожалуйста, не обращайте внимания, он дезинформирован. Оставив для потомков;)

Однако, вот ссылка, которую я нашел относительно распределения памяти двумерных массивов в С ++. Возможно, это будет более ценно.

Не уверен, что это то, что вы хотите, и прошло некоторое время с тех пор, как я написал c ++, но причина вашего сбоя приведения в том, что вы переходите от массива массивов к указателю на целые числа. Если, с другой стороны, вы попробуете перейти от массива к массиву к указателю указателей, это, скорее всего, сработает.

int tempSec[3][3]; 
int** pTemp = tempSec; 

помните, ваш массив массивов на самом деле является непрерывным блоком памяти, содержащим указатели на другие смежные блоки памяти — вот почему приведение массива массивов к массиву целых чисел даст вам массив того, что выглядит как мусор [этот мусор на самом деле адреса памяти!].

Опять же, зависит от того, чего вы хотите. Если вы хотите, чтобы это было в формате указателя, указатель указателей — это путь. Если вы хотите, чтобы все 9 элементов были одним непрерывным массивом, вам придется выполнить линеаризацию двойного массива.

Problem with array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>

#define COL 3
#define ROW 5

using namespace std;

int** func(int** mas)
{
    //some code
    return mas;
}

int main()
{
    int arr[COL][ROW]={{2,3,1,4,5},{12,32,43,1,23},{6,65,7,43,11}};
    int **p;

    p=func(arr); //In that line error, but I don't know how to fix it

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>

#define COL 3
#define ROW 5

using namespace std;

int** func(int mas[COL][ROW])
{
    int (*p)[ROW];
    p=mas;

    //some code

    return p;                             //mistake in this line
}

int main()
{
    int arr[COL][ROW]={{2,3,1,4,5},{12,32,43,1,23},{6,65,7,43,11}};
    int (*p)[ROW];
    p=arr;

    p=func(arr);                        //and in that one

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# include <iostream>

# define COL 3
# define ROW 5

using namespace std;

int** func(int mas[][ROW])
{
    int **tmpVar;
    tmpVar = new int*[ROW];
    for(int i=0;i<ROW;i++)
        tmpVar[i] = new int[COL];

    for(int i=0;i<ROW;i++)
    for(int j=0;j<COL;j++)
        tmpVar[j][i] = mas[j][i];

    return tmpVar;
}

int main()
{
    int arr[COL][ROW]={{2,3,1,4,5},{12,32,43,1,23},{6,65,7,43,11}};
    int **p;

    p=func(arr); //The error is not here !

    for(int i=0;i<ROW;i++)
    {
        for(int j=0;j<COL;j++)
        cout << p[j][i] << " ";
        cout << endl;
    }

    return 0;
}

Topic archived. No new replies allowed.

1. Pointer Preliminaries in C++
2. the Conversion Error
3. Resolve the Conversion Error

This short tutorial will discuss the error message "Invalid conversation of int* to int". First, let’s have a recap of the pointers in C++.

Pointer Preliminaries in C++

Pointers are used to hold the address (a hexadecimal value) of a variable, and it is assigned to the pointer type variable using the ampersand sign(&), also known as the address operator preceded to the variable name.

Pointers are declared using the * symbol like this:

We can assign the address of an integer variable to an integer pointer using the following statement:

The above line of code will assign the address of the integer variable a to the integer pointer p.

the Conversion Error

When an integer variable is assigned a hexadecimal address value of variable instead of an integer type value, the “invalid conversion from int* to int” error occurs.

Example Code:

#include <iostream>
using namespace std;

int main()
{
    int a=10;
    int p;
    p=&a; // invalid conversion error
    cout<< p;
}

The above code will generate a conversion error on line 07 as p is assigned an address of type int* that can’t be stored in an integer variable.

Output:

main.cpp: In function 'int main()': main.cpp:7:7: error: invalid conversion from 'int*' to 'int' [-fpermissive] ptr = &p; //invalid conversion. ^

Resolve the Conversion Error

Most compilers don’t allow a type casting from pointer type to the simple datatype. Therefore, the issue can be solved by ensuring that the address type value is assigned to a proper pointer variable.

Example Code:

#include <iostream>
using namespace std;

int main()
{
    int a=10;
    int* p;
    p=&a;
    cout<< p;
}

Run Code

The * symbol while declaring p will make it a pointer to an integer. Thereby making it capable of storing the address of an integer variable without requiring any type-conversions.