how can i fix the function a3 to obtain my output - arrays

Question

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char null;
static char a3[](char a[], int start, int length)
{
if(length < 0 || start < 0 || start + length -1 >= sizeof(a))
{
return null;
}
char sub[] = new char[length];
for (int i=start, j=0; j<length; i++, j++)
{
sub[j] = a[i];
}
return sub;
}
int main()
{
char a[]= {'a', 'b','c'};
int start = 0;
int length = 3;
printf("%d\n", a3(a, start,length));
return 0;
}
I want to write a function that accepts a character array, a zero-based start position, and a length. It should return a character array containing length characters starting with the start character of the input array. The function should do error checking on the start position and the length and return null if either value is not legal. when I build it gives me the following error " error: expected '=', ',', ';', 'asm' or 'attribute' before '{' token|". I don't know how to fix this error. Can anyone help me ??

Answer 1

Values of array type cannot be passed to functions, returned from functions, or assign to an object of array type. However, a pointer to an element of an array can be passed to a function or returned from a function. Therefore, the prototype of function a3 should be something like:
static char *a3(char a[], int start, int length)
A function parameter of array type is automatically adjusted to have pointer type and will point to the first element of the array. Therefore the above prototype is equivalent to:
static char *a3(char *a, int start, int length)
The function cannot determine the size of the array because the array parameter is actually just a pointer. The expression sizeof(a) in function a3 is equivalent to sizeof(char *) and is unrelated to the length of the array. The function will need to be told the length of the array in some other way, perhaps with another parameter:
static char *a3(char *a, int a_len, int start, int length)
Then the code to test for correct parameters can be something like:
if (length < 0 || start < 0 || start + length > a_len)
{
return NULL;
}
Note that NULL is a null pointer constant and the returned value will be a null pointer value of type char *. This is preferable to the existing code that converts the value of the variable null to a char * without a cast.
If you create an array or other variable with automatic storage class in a function or block, it ceases to exist when the end of the function or block is reached. Therefore, if the function returns a pointer to such a variable, the pointer will be invalid. The caller cannot use it to access the contents of the variable, since it no longer exists. Therefore, the function should use the memory management functions such as malloc or calloc to allocate storage for the object and return a pointer to that storage. The storage persists at the address until free is called to free the storage, or realloc is called to change its size.
The existing code uses the C++ new operator to create the storage for array sub, but that is not supported by C. The C equivalent is to declare sub as a pointer and use malloc or calloc to allocate the storage. (calloc also sets all bytes of the returned memory block to 0.):
char *sub = malloc(length * sizeof(char));
or:
char *sub = calloc(length, sizeof(char));
Note that sizeof(char) is 1 by definition, so the above can be simplified to:
char *sub = malloc(length);
or:
char *sub = calloc(length, 1);
It is possible for malloc or calloc to fail to allocate the memory (unlikely for small programs allocating small amounts of memory), in which case they return a null pointer. The function should check for that and return an error:
if (sub == NULL)
{
return NULL;
}
There is an error in main where it is using the printf %d specifier to print the return value of a3(). The %d specifier expects a value of type int (after default argument promotions), so I do not know what OP expects to print there.
Putting it all together and changing the main function to print something sensible, we have the following:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char *a3(char a[], int a_len, int start, int length)
{
if(length < 0 || start < 0 || start + length > a_len)
{
return NULL;
}
char *sub = malloc(length);
if (sub == NULL)
{
return NULL;
}
for (int i=start, j=0; j<length; i++, j++)
{
sub[j] = a[i];
}
return sub;
}
int main(void)
{
char a[]= {'a', 'b','c'};
int a_len = 3;
int start = 0;
int length = 3;
char *sub = a3(a, a_len, start, length);
if (sub == NULL)
{
printf("Error\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < length; i++)
{
printf("%c", sub[i]);
}
printf("\n");
free(sub); // free the storage returned by a3()
return 0;
}
There are various improvements that could be made. For example, the a parameter of a3 can be changed to const char *a (or const char a[] since that will be adjusted to const char *a) to indicate that it does not modify the contents pointed to by a.