Check If Element Found in Array C++

Check if element found in array c++

In C++ you would use std::find, and check if the resultant pointer points to the end of the range, like this:

Foo array[10];
... // Init the array here
Foo *foo = std::find(std::begin(array), std::end(array), someObject);
// When the element is not found, std::find returns the end of the range
if (foo != std::end(array)) {
    cerr << "Found at position " << std::distance(array, foo) << endl;
} else {
    cerr << "Not found" << endl;
}

C - If value in array

float arr[] = ...;

declares an array(because of []) of floats(because of the float keyword) that is called arr. Similarly in a function declaration:

int valueinarray(float val, float *arr[]);

means that the second argument is a pointer(because of *) to an array(because of[]) which isn't what you need at all. You need to accept just an array:

int valueinarray(float val, float arr[]);

folowing this logic your code would look like this:

int valueinarray(float val, float arr[])
{
    int i;
    for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        if(arr[i] == val)
            return 1;
    }
    return 0;
}

Notice a number of changes:

1. The function parameter arr is now an array.

2. The expression

   sizeof(arr) / sizeof(arr[0])
   first takes the size of arr the array in bytes. Then divides it by the size in bytes of the first element in it. And now we are left with the number of elements. If it were a char array, then this is not needed is 1 char takes up 1 byte. For any other type it is necessary. As a side note you could've divided by sizeof(float), but this makes it harder for you if you change the type and is a worse practice than sizeof(arr[0]).

If you didn't divide you could have an array of 10 floats, but you could try to access 40. So you'd be meddling with 120 bytes of the memory right after your array that aren't yours.

Also the asterisk * dereferences outside of declarations. If you have:

int a[5];
int x = 5;
int *pointerToInt = &x;

then x is a label for some memory (variable) that stores the value 5. &x is a pointer to the memory that stores the label. The opposite of & is *. Whlie pointerToInt equals &x, *pointerToInt equals x. Also *a equals a[0], but isn't literally the same, *(a+1) equals a[1].

how to check if an array position exist?

Each position in a C array, within the array's bounds, always exists, so there's no need for a way to check a random position for existence. All you need to do is make sure that the index is inside the bounds.

If the array is declared with a static size, you can get the length of the array via sizeof:

int array[30];
int length = sizeof(array) / sizeof(int);
// sizeof(array) returns the size in bytes, divide by element size to get element count

However if the array doesn't have a known length at compile time, you'll have to find it out in some other way. C functions dealing with arrays usually take in both a pointer to the first element and the size as separate arguments.

void do_something_to(int *items, int item_count);

You need to be especially careful when passing arrays to functions, since an array passed to a function becomes a "plain pointer" and the compiler loses all track of its size (sizeof will report the size of the pointer). IMHO it's least confusing to avoid array arguments altogether and just stick to pointers.

Function to verify if an element present in an array

int flag = checkElement(a1, element);

int checkElement(Array *a, int elem){
for (int i = 0; i < a->size; i++){
    if (a->array[i] == elem){
        return 1;
    }
}
    return 0;
}

Find if an element exists in C++ array [duplicate]

There is a standard function called std::find in the header <algorithm>:

#include <iostream>
#include <algorithm>

int main() {
    int myarray[6]{10, 4, 14, 84, 1, 3};

    if (std::find(std::begin(myarray), std::end(myarray), 1) != std::end(myarray))
        std::cout << "It exists";
    else
        std::cout << "It does not exist";
    return 0;
}

Ideone

Check if element in an array is of type int

Number or type int (as in the title)?

You have a string of length 20. How do you define a number? A sequence of digits? This loops through the array and finds isolated digits, then uses atoi() and atof() to convert.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

void main(void)
{
    char arr[20];

    fgets(arr, sizeof arr, stdin);

    printf("STRING: %s\n", arr);

    for (int i = 0; (arr[i]); i++)
    {
            if (isdigit(arr[i]))
                printf("Digit: %c\n", arr[i]);
            else
                printf("%c\n", arr[i]);
    }

    printf("atoi: %d\n", atoi(arr));
    printf("atof: %f\n", atof(arr));

}

Output:

STRING: -3.1411isnegpi

-
Digit: 3
.
Digit: 1
Digit: 4
Digit: 1
Digit: 1
i
s
n
e
g
p
i


atoi: -3
atof: -3.141100

And also:

STRING: 1e22

Digit: 1
e
Digit: 2
Digit: 2


atoi: 1
atof: 10000000000000000000000.000000

Checking for digits in a string is trivial, but to extract "numbers" is not. Is "1e22" numbers 1 and 22? Is "abc10" a number?

How can I check if given int exists in array? [duplicate]

You can use std::find for this:

#include <algorithm> // for std::find
#include <iterator> // for std::begin, std::end

int main () 
{
  int a[] = {3, 6, 8, 33};
  int x = 8;
  bool exists = std::find(std::begin(a), std::end(a), x) != std::end(a);
}

std::find returns an iterator to the first occurrence of x, or an iterator to one-past the end of the range if x is not found.

---

Related Topics