how to slice an array in c - c

Question

I am wondering if it is possible to get part of an array in c, with list slicing. In python it van be done in de next code. I like to do this in c.
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = a[3:5]
print(b)
Output: [4, 5]

Answer 1

You can use a struct as an array wrapper in the slice function. This way you can return the extracted slice from the function without bothering with malloc and free for dynamic memory allocation. Here's a basic outline.
#define MAX 100
typedef struct{
int myarr[MAX];
int mysize;
} wrapper;
wrapper slice(const int* arr, int size, int include, int exclude) {
wrapper result = { .myarr = {0}, .mysize = 0 };
if (include >= 0 && exclude <= size) {
int count = 0;
for (int i = include; i < exclude; i++) {
result.myarr[count] = arr[i];
count++;
}
result.mysize = exclude - include;
return result;
}
else {
printf("Array index out-of-bounds\n");
result.mysize = -1;
return result;
}
}
This can then be called on any array as follows:
int source[10] = {0,1,2,3,4,5,6,7,8,9};
wrapper s = slice(source, 10, 5, 10);
It will take quite a bit more work to implement the full Python slice functionality, though (here there's no third term to set the step size, nor are the various negative values implemented).

Answer 2

Well, you could start with something like the following:
// Get half-open range of values from array (includes first index,
// excludes last). Parameter 'source' is the source array, 'from'
// and 'to' are the range ends, and `target` is the destination
// buffer. If you provide buffer, make sure it's big enough. If
// you pass in NULL, a buffer will be allocated for you.
// Will return buffer address or NULL if either range is invalid
// or memory could not be allocated.
int *sliceIntArray(int *source, int from, int to, int *target) {
// Invalid, return null.
if (to <= from) {
return NULL;
}
// Only allocate if target buffer not given by caller.
if (target == NULL) {
target = malloc((to - from) * sizeof(int));
if (target == NULL) {
return NULL;
}
}
// Copy the data and return it.
memcpy(target, &(source[from]), (to - from) * sizeof(int));
return target;
}
This lets you pass in a buffer if you already have it, or it will allocate one for you if you don't (which you will need to free() at some point):
int naturals[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int slice1[2];
sliceIntArray(naturals, 3, 5, slice1);
// Use slice1 for whatever nefarious purpose you have :-)
int *slice2 = sliceIntArray(naturals, 3, 5, NULL);
// Use slice2 similarly, just make sure you free it when done.
free(slice2);

Answer 3

No, you can't.
You can create a new array and copy it, though:
int src[10] = { ... };
int dest[3];
memcpy(dest, src + 3, sizeof(src[0]) * 2);

Answer 4

In a short simple function:
int* slice(int a[], size_t start, size_t end)
{
return memcpy(malloc(sizeof(int)*(end-start)), a+start, sizeof(int)*(end-start));
}
Example usage:
#include <stdio.h>
int main(void) {
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *b = slice(a,3,5);
for(int i=0; i<2; ++i)
{
printf("b[%d] = %d\n", i, b[i]);
}
return 0;
}
Output:
b[0] = 4
b[1] = 5