Storing and retrieving combination of characters and integers in an array - c

Question

I want to create an array in which i can store run time supplied input such as - + 2 * 3 4 / 12 6 (total 9 elements here). Suppose none of input instances require more than 50 indices in array. I'm thinking of an integer array for this purpose but i'm not getting any format specifier which can be used in scanf() for taking input (terminated at return/Enter keypress ) so that i can distinguish latter in the program whether particular index was a char or int and what was its value.
If i use %c or even getchar() function I'm facing trouble to handle integers more than one digit.
if i use %d chars such as * + - / are not getting stored. so on and so forth.
So kindly suggest some way to do it if it is feasible.

Answer 1

When I learned programming (long time ago ...) my teacher said "never begin to code until it is clear what you want to achieve with a correct analysis". If I correctly understood, you are building a calculator, with only five operators (+-/*%) that follows following grammar :
expr : number
| operator expr expr
with the following lexical tokens :
operator: single character among +-*/%
number: consecutive sequence of decimal digits ([0-9]*)
not printing characters (space, tab, \r, \n) are used as delimiters or otherwise ignored
any other character causes an error.
Ok : that's your current specs, if you later want to use decimal numbers you just have to change the number definition to allow one optional decimal point.
Written like that, it would be easy to use lex and yacc, but for such a simple grammar, it is certainly overkill.
Even if we defined spaces as separator, it is not possible to use scanf to get tokens, because it would silently eat + signs : +12 is same as 12.
So you must build a simple lexer using getc that returns tokens, and then a parser that recursively compute expressions. No need for storing anything in arrays :
typedef struct _token {
enum {OPERATOR, INT, END, ERROR } type;
union {
int ival;
char op;
} value;
} TOKEN;
TOKEN getToken(FILE *fdin) {
static const char valid_op[] = "+-*/%";
static const char spaces[] = " \t\r\n";
int c;
TOKEN tok;
int val = 0;
int isval = 0;
while ((c = getc(fdin)) != EOF) {
if ((c >= '0') && (c <= '9')) {
val = 10 * val + (c - '0');
isval = 1;
}
else if (isval != 0) {
tok.type = INT;
tok.value.ival = val;
ungetc(c, fdin);
return tok;
}
else if (strchr(valid_op, c)) {
tok.type = OPERATOR;
tok.value.op = c;
return tok;
}
else if (! strchr(spaces, c)) {
tok.type = ERROR;
return tok;
}
}
tok.type = END;
return tok;
}
int parse(FILE *fdin, int *typ) {
int i, j;
*typ = INT;
for(;;) {
TOKEN tok = getToken(fdin);
if (tok.type == INT) {
return tok.value.ival;
}
else if (tok.type == OPERATOR) {
i = parse(fdin, typ);
if (*typ != INT) {
*typ = ERROR;
return 0;
}
j = parse(fdin, typ);
if (*typ != INT) {
*typ = ERROR;
return 0;
}
switch(tok.value.op) {
case '+': return i+j;
case '-': return i-j;
case '*': return i*j;
case '/': return i/j;
case '%': return i * j / 100;
}
}
else {
*typ = tok.type;
return 0;
}
}
}

Answer 2

You need a data type that can hold various types of data: operators and integers, maybe even floating-point numbers or names (of variables or functions).
A common approach in C is to use a union, which can hold several types in the same space. You can only use one of these types at a time, so you need a way to indicate which of the types is active, which can be done with an enum. Then wrap the enum and the union in a struct to have them tidily alongside each other.
Below is an example implementation of auch a data type. It doesn't do any operations, it only parses a string and prints the tokens.
As in your example, all tokens must be separated by white space, so that strtok can find them. If you want to recognize 5/2 as three tokens, you can build a lexer as Serge Ballesta suggested in his very systematic answer. The implementation below doesn't recognize negative numbers such as -1. Error handling is also very basic.
This code might still serve you as starting point for a solution:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
enum Type { /* enumeration of possible types */
Operator,
Integer,
Float,
Name,
Illegal
};
struct Token {
enum Type type; /* token type */
union { /* mutually exclusive data fields */
long long int l; /* ... for Integer */
double x; /* ... for Float */
char name[20]; /* ... for Name and Operator */
} data;
};
struct Token illegal(const char *str)
{
struct Token tk = {Illegal};
snprintf(tk.data.name, 20, "%s", str);
return tk;
}
struct Token parse(const char *str)
{
struct Token tk = {Illegal};
if (strchr("+-*/%", *str)) {
if (str[1]) return illegal("Overlong operator");
tk.type = Operator;
strcpy(tk.data.name, str);
return tk;
}
if (isdigit(*str)) {
double x;
long long l;
char *end;
l = strtoll(str, &end, 0);
if (end != str && *end == '\0') {
tk.type = Integer;
tk.data.l = l;
return tk;
}
x = strtod(str, &end);
if (end != str && *end == '\0') {
tk.type = Float;
tk.data.x = x;
return tk;
}
return illegal("Illegal number");
}
if (isalpha(*str)) {
const char *p = str;
while (*p) {
if (!isalnum(*p++)) return illegal("Illegal name");
}
tk.type = Name;
snprintf(tk.data.name, 20, "%s", str);
return tk;
}
return illegal("Illegal character");
}
int split(struct Token tk[], int max, char *str)
{
int n = 0;
char *p;
p = strtok(str, " \t\n");
while (p) {
struct Token curr = parse(p);
if (curr.type == Illegal) {
fprintf(stderr, "Parse error: %s.\n", curr.data.name);
return -1;
}
if (n < max) tk[n] = curr;
n++;
p = strtok(NULL, " \t\n");
}
return n;
}
void print(struct Token tk)
{
switch (tk.type) {
case Operator: printf("operator %c\n", tk.data.name[0]);
break;
case Integer: printf("integer %lld\n", tk.data.l);
break;
case Float: printf("float %g\n", tk.data.x);
break;
case Name: printf("name \"%s\"\n", tk.data.name);
break;
default: printf("illegal token\n");
}
}
int main()
{
char line[] = "- + 2 * alpha beta / 12.0 6";
struct Token tk[20];
int i, n;
n = split(tk, 20, line);
for (i = 0; i < n; i++) {
print(tk[i]);
}
return 0;
}

Answer 3

Use
fgets() to read till end of line.
Parse the line and break the line into tokens using strtok() with space as delimiter.
Check whether each token is char or digit. There are multiple ways to check whether the token is digit or not. Use strtol() to convert tokens to integers this will help you to find difference between 0 and character also