Error invalid operands to binary expression float and float

The invalid operands to binary expression C++ error might occur when a variable or object is considered a function. Moreover, you might get the same error due to using the wrong types of operands with the operators. If you are still in the same confused state, then read further to find a detailed explanation.

By the end of this post, you’ll surely figure out the erroneous line in your code, understand the reason, and have the perfect solution.

Why Do Invalid Operands To Binary Expression C++ Error Occur?

The above error might be occurring due to the most vexing parse that indicates the interpretation of an object as a function call. Moreover, the invalid operands or the external operands throw the same error. You can read below the complete descriptions of the reasons that have been stated earlier:

– Most Vexing Parse

The most vexing parse tells you that the variable declaration or object creation was considered a function call. Hence, you will get the above error when you use the same variable later in your program as an operand.

You can understand the scenario by imagining that you have declared a variable but accidentally placed a parenthesis in front of it. Next, you’ve coded to store the input inside the same and now, you are trying to print it. Here, you will get the above error because C++ grammar considered the variable declaration as a function call.

The coding block for the above scenario has been attached below:

#include <iostream>
using namespace std;
int main()
{
int age();
cout << “Please enter your age here: “;
cin >> age;
cin.ignore();
cout << “Your age is: “<< age <<“n”;
cin.get();
}

– Using Modulus With Variables of Double Data Type

As shown in the error statement itself, the invalid operands cause the stated error. The most common situation depicting the given reason is when the modulus “%” is used with the operands of double data type. Know that you can use only integers with the modulus.

– Using a Comparison Operator With External Class Objects

You might get the said error while comparing the properties of external class objects.

Here is the code that depicts the above scenario:

#include <iostream>
using namespace std;
class Plant{
public:
int height;
};
int main(){
Plant a, b;
a.height = 20;
b.height = 25;
if(a != b){
// do something
}
}

– Using a Comparison Operator With Operands That Can’t Be Compared

Another reason for the invalid operands error can be comparing the operands that can’t be compared. Here, you can imagine comparing a float variable with the void. It will definitely throw the same error.

You can fix the invalid operands error by implementing one of the solutions shared below as per the erroneous code found in your program:

– Remove the Parenthesis Following the Variable Name

So, if you have confused the C++ compiler regarding the variable and it has interpreted the same as a function, then remove the parenthesis following the variable name. It will solve the issue.

– Cast the Modulus Operands To Int

You can cast the modulus operands to int data type to make the above error go away. Similarly, casting the operands according to the operator requirement will help you every time when you face the same error.

– Round the Function Output and Cast It To Int

If your binary expression that uses the modulus contains the function output as an operand, then it would be a better idea to round the output. Next, you can convert the same into int to make the expression work.

– Overload the Comparison Operator Outside the Class

Pointing towards the error caused while comparing the external class objects’ properties, you can solve the same by overloading the given operator. It will ensure that the operator is already aware of the required class.

Please look at the code shown above that uses the Plant class and then see here to solve the issue:

#include <iostream>
using namespace std;
class Plant{
public:
int height;
};
static bool operator!=(const Plant& obj1, const Plant& obj2) {
return obj1.height != obj2.height;
}
int main(){
Plant a, b;
a.height = 20;
b.height = 25;
if(a != b){
cout << “The heights aren’t the same.” << endl;
}
}

– Fix the Operands To Eliminate Invalid Operands To Binary Expression C++ Error

Double-check the operands that you are comparing and change them accordingly to solve the error.

FAQ

You can find more information in this section.

– What Does the Error “Invalid” Operands To Binary >> (Double and Int) Tells?

The “invalid” operands to binary >> (double and int) error shows up to tell you that you are using the “>>” operator with operands of double data type. Remember that you can use “>>” with the values of integer data type only.

Conclusion

Fixing the stated error in your code isn’t a big deal after learning about the above solutions. Here is the simplified list of the solutions to let you see the fixing processes through the broader side:

• You can fix the above error by removing any syntax errors that confuse the C++ compiler between variables and functions
• Casting and changing the operands as per the operator requirement can help you fix the above error
• Overloading the operators can help you in using external class objects in binary expressions

Certainly, the said error revolves around the invalidity of the operands. You should simply be careful while using the same to avoid the error.

G

The code of your question is an image processing algorithm called Masks values are coefficients and the filtration process is similar to a mathematical operation called In essence, the implementation of your Filtro Espacial is correct! Your code error is the time you read and record https://en.wikipedia.org/wiki/Netpbm_format#PGM_example .ppmNote that you are reading the image dimensions in an inverted way. You are changing the amount of rows with the amount of image columns.Follow a tested and commented code capable of applying a Filtro Espacial Gaussiano de Smooth in a format image .ppm: #include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define LINE_MAX_LEN (64)
/* Representa um pixel da imagem */
typedef struct pixel_s
{
unsigned char red;
unsigned char green;
unsigned char blue;
} pixel_t;
/* Representa uma imagem */
typedef struct image_s
{
pixel_t ** buf;
int ncols;
int nrows;
} image_t;
image_t * image_create( int ncols, int nrows )
{
int i = 0;
image_t * img = (image_t*) calloc( 1, sizeof(image_t) );

img-&gt;buf = (pixel_t**) calloc( nrows, sizeof(pixel_t*) );

for( i = 0; i &lt; nrows; i++ )
img-&gt;buf[i] = (pixel_t*) calloc( ncols, sizeof(pixel_t) );

img-&gt;ncols = ncols;
img-&gt;nrows = nrows;

return img;

}
void image_destroy( image_t * img )
{
int i = 0;
for( i = 0; i &lt; img-&gt;nrows; i++ )
free(img-&gt;buf[i]);

free(img-&gt;buf);
free(img);

}
pixel_t * image_read_pixel( image_t * img, int col, int row )
{
/* Nao permite leitura fora das fronteiras da imagem original */
if( col >= img->ncols ) col = img->ncols — 1;
if( row >= img->nrows ) row = img->nrows — 1;
if( col < 0 ) col = 0;
if( row < 0 ) row = 0;
return &amp;img-&gt;buf[row][col];

}
image_t * image_gaussian_smooth_filter( image_t * img )
{
int x, y, col, row, newpx;
pixel_t * px;
int sum, div;
int kernel[5][5] = {{ 2, 4, 5, 4, 2 },
{ 4, 9, 12, 9, 4 },
{ 5, 12, 15, 12, 5 },
{ 4, 9, 12, 9, 4 },
{ 2, 4, 5, 4, 2 }};

/* Debug */
printf( «Filtrando Imagem: tipo=P3; nrows=%d; ncols=%dn», img-&gt;nrows, img-&gt;ncols );

image_t * newimg = image_create( img-&gt;ncols, img-&gt;nrows );

for( row = 0; row &lt; img-&gt;nrows; row++ )
{
for( col = 0; col &lt; img-&gt;ncols; col++ )
{
sum = 0;
div = 0;

for( y = 0; y &lt; 5; y++ )
{
for( x = 0; x &lt; 5; x++ )
{
px = image_read_pixel( img, col + (x — 2), row + (y — 2) );
sum += ( px-&gt;red * kernel[y][x] );
div += kernel[y][x];
}
}

newpx = sum / div;

newimg-&gt;buf[row][col].red = newpx;
newimg-&gt;buf[row][col].green = newpx;
newimg-&gt;buf[row][col].blue = newpx;
}
}

return newimg;

}
int image_save( const char * file, image_t * img )
{
int col = 0;
int row = 0;
FILE * pf = fopen( file , «w» );

if(!pf)
return -1;

fprintf( pf, «P3n»);
fprintf( pf, «# Arquivo PPM de saidan»);
fprintf( pf, «%d %dn», img-&gt;ncols, img-&gt;nrows );
fprintf( pf, «255n» );

/* Debug */
printf( «Gravando Imagem: arquivo=%s; tipo=P3; nrows=%d; ncols=%d; componente=255n», file, img-&gt;nrows, img-&gt;ncols );

for( row = 0; row &lt; img-&gt;nrows; row++)
{
for( col = 0; col &lt; img-&gt;ncols; col++ )
{
fprintf( pf, «%un», img-&gt;buf[row][col].red );
fprintf( pf, «%un», img-&gt;buf[row][col].green );
fprintf( pf, «%un», img-&gt;buf[row][col].blue );
}
}

fclose(pf);

return 0;

}
image_t * image_load( const char * file )
{
int col = 0;
int row = 0;
char tipo[3];
char line[LINE_MAX_LEN];
int header_index = 0;
int componente = 0;
int nrows = 0;
int ncols = 0;
image_t * img = NULL;
FILE * pf = fopen( file, «r» );

if(!pf)
return NULL;

/* Carega o Header do Arquivo PPM */
while( fgets( line, LINE_MAX_LEN, pf ) )
{
if( header_index == 0 )
{
sscanf( line, «%s», tipo );
header_index++;
}
else if(header_index == 1 )
{
header_index++;
}
else if(header_index == 2 )
{
sscanf( line, «%d %d», &amp;ncols, &amp;nrows );
header_index++;
}
else if( header_index == 3 )
{
sscanf(line, «%d», &amp;componente);
break;
}
}

/* Debug */
printf( «Carregando Imagem: arquivo=%s; tipo=%s; nrows=%d; ncols=%d; componente=%dn», file, tipo, nrows, ncols, componente );

/* Verifica se o tipo do arquivo eh P3 */
if( tipo[0] != ‘P’ || tipo[1] != ‘3’)
{
fclose(pf);
return NULL;
}

/* Cria uma imagem em branco */
img = image_create( ncols, nrows );

/* Carrega imagem */
for( row = 0; row &lt; nrows; row++)
{
for( col = 0; col &lt; ncols; col++)
{
/* Componente Vermelho */
fgets(line, LINE_MAX_LEN, pf );
sscanf( line, «%hhu», &amp;img-&gt;buf[row][col].red );

/* Componente Verde */
fgets( line, LINE_MAX_LEN, pf );
sscanf( line, «%hhu», &amp;img-&gt;buf[row][col].green );

/* Componente Azul */
fgets( line, LINE_MAX_LEN, pf );
sscanf( line, «%hhu», &amp;img-&gt;buf[row][col].blue );
}
}

fclose(pf);

return img;

}
int main( void )
{
/* Carrega imagem a partir do arquivo */
image_t * original = image_load( «imagem_cinza.ppm» );
if(!original)
{
printf(«Erro ao carregar imagem PPM.n»);
return 1;
}

/* Aplica filtro */
image_t * filtered = image_gaussian_smooth_filter( original );

/* Grava imagem filtrada em arquivo */
int ret = image_save(«imagem_filtrada.ppm», filtered );

if(ret &lt; 0)
{
printf(«Erro ao salvar imagem PPM.n»);

/* Libera memoria ocupada pelas imagens */
image_destroy(filtered);
image_destroy(original);

return 1;
}

/* Libera memoria ocupada pelas imagens */
image_destroy(filtered);
image_destroy(original);

return 0;

}
Output:Carregando Imagem: arquivo=imagem_cinza.ppm; tipo=P3; nrows=480; ncols=610; componente=255
Filtrando Imagem: tipo=P3; nrows=480; ncols=610
Gravando Imagem: arquivo=imagem_filtrada.ppm; tipo=P3; nrows=480; ncols=610; componente=255
Original Image: Filtered image: References: http://dcm.ffclrp.usp.br/~murta/PIM/PIM_2.pdf http://www.facom.ufu.br/~backes/gsi058/Aula06-FiltragemEspacial.pdf http://www.coe.utah.edu/~cs4640/slides/Lecture5.pdf

#include"Oblik.h"
#include<cmath>

using namespace std;

class Jednakostranicni : public GeometrijskaFigura{

    float P(){
        return (a*a*sqrt(3))/4; //12    13  C:UsersNameDesktopprvi.cpp  [Error] invalid operands of types 'float*' and 'float*' to binary 'operator*'
    }
    float O(){
        return a+a+a; //15  12  C:UsersNameDesktopprvi.cpp  [Error] invalid operands of types 'float*' and 'float*' to binary 'operator+'
    }
    
};

class Kvadrat : public GeometrijskaFigura{
    
    float P(){
        return a*a;//23 12  C:UsersNameDesktopprvi.cpp  [Error] invalid operands of types 'float*' and 'float*' to binary 'operator*'
    }
    float O(){
        return a+a+a+a;//26 12  C:UsersNameDesktopprvi.cpp  [Error] invalid operands of types 'float*' and 'float*' to binary 'operator+'
    }
    
};

class Krug : public GeometrijskaFigura{
    
    float P(){
        return a*a*3.14;//34    12  C:UsersNameDesktopprvi.cpp  [Error] invalid operands of types 'float*' and 'float*' to binary 'operator*'
    }
    float O(){
        return 2*a*3.14;//37    12  C:UsersNameDesktopprvi.cpp  [Error] invalid operands of types 'int' and 'float*' to binary 'operator*'
    }
    
};

int main(){
    
    GeometrijskaFigura *f;
    int x;
    
    cin>>x;
    
    f->setA(x);
    
    f=new Jednakostranicni;
    cout<<"Jednakostranicni-P: "<<f->P()<<" O: "<<f->O()<<endl;
    f=new Kvadrat;
    cout<<"Kvadrat-P: "<<f->P()<<" O: "<<f->O()<<endl;
    f=new Krug;
    cout<<"Krug-P: "<<f->P()<<" O: "<<f->O()<<endl;
    
    
    
    return 1;
    
    
}

// this is Oblik.h file code
#include<iostream>

using namespace std;

class GeometrijskaFigura{
    protected: float a;
    public:
        
        void setA(float b){
         a=b;
        }
        
        virtual float P()=0;
        virtual float O()=0;
};

1 ответ

Лучший ответ

GeometrijskaFigura *f;
int x;
    
std::cin >> x;
    
f->setA(x); // UB: use uninitialized f.

int a;

std::cin >> a;

Jednakostranicni j;
j.setA(a);
std::cout << "Jednakostranicni-P: " << a.P() << " O: " << a.O() << std::endl;

Kvadrat k;
k.setA(a);
std::cout << "Kvadrat-P: " << k.P() << " O: " << k.O() << std::endl;

Krug krug;
krug.setA(a);
std::cout << "Krug-P: " << krug.P() << " O: " << krug.O() << std::endl;

Error: invalid operands of types 'int' and 'float*' to binary'operator/'
int *average = new int((num) / data);

float *data;
int num;
int mode;
double average, median;

cout << "How many students were surveyed?  ";
cin >> num;
data = makeArray(num);

float getAverage(float *data, int num)
{
int *average = new int((data) / num);
return *average;
}

Решение

//your code:
float getAverage( float *data, int sum )
{
//data is a float* and needs to be de-ref'd and casted to int for float but isnt
int *average = new int( (data) / num );
//note that now average is a pointer to a newly constructed int that will never be free'd
return *average;  //because you return it here, where the value will then be implicily converted to a float and be mostly worthless.
}

// In both suggestions I will use symmetric types, I will not introduce dynamic memory and I will use floating point division for maximal accuracy.

// Suggestion one use Const References
float getAverage( const float &data, const int &num)
{
float result = data / (float) num;
return result;
}

// Suggestion two use pointers to constants
float getAverage( const float *data, const int *num )
{
float result = (*data) / float(*num);
return result;
}

// Suggestion three pass by value since primitives are cheap
float getAverage( float data, int num)
{
float result = data / (float) num;
return result;
}

Другие решения

Других решений пока нет …