How compare vector size with an integer? [closed]

Answer 1

Use the size_t type to hold collection sizes:

vector<int> vectorX;
size_t intendedSize = 10;
// Some stuff here
if(vectorX.size() != intendedSize) {
     ... 
}

Actually technically you should use vector<int>::size_type but in practice this is always a typedef for size_t

An int is usually a signed 32-bit integer.

size_t is usually an unsigned 64-bit integer (on 64-bit architectures) or an unsigned 32-bit integer (on 32-bit architectures).

(Note that the standard doesn't enforce those constraints. The ABI specifies this, for example the x86 and x86-64 ABI do.)

Answer 2

I'm writing this answer because the other two, including the accepted one, are both wrong. The type of std::vector's size() is not unsigned int, nor it is size_t.

The type of the size of an std::vector<T> is std::vector<T>::size_type.

That's it. On some architecture and for some compilers it might be the same as size_t, in some others it might not. The assumption that a variable of type size_t can hold the same values than one of type std::vector<T>::size_type can fail.

To check that your vector has the right size you could do something like:

if(vec.size() != static_cast<std::vector<int>::size_type>(expected_size)) {
    std::cerr << "Error!" << std::endl;
}

Answer 3

You are missing ) in the right side of if statement

if((int)(vectorX.size()) != (intendedSize)) {
                                          ^^^
}

But note, it's bad to cast return value of std::vector::size to int. You lose half of the possibilities of what the size could be(thanks to chris).

You should write:

size_t intendedSize = 10; 
// OR unsign int intendedSize  = 10; 
if(vectorX.size() != intendedSize) {
}