[BC3] C functie gezocht.

[Orbit]

Ik zit een beetje vast met een oef voor C (dus geen C++).

Ik ben op zoek naar een voorgedefinieerde functie die checkt of het gegeven een getal is. Met "isdigit()" uit "ctype.h" kan je checken of het een cyfer is ( 0 1 2 3 4 5 6 7 8 9 dus). Maar ik heb meer nodig, ik moet een array checken op juist input, dus of alles wel degelijk cyfers zijn ipv letters of weet ik veel wat een domme user kan invoeren.

Iemand een id-tje?

[dusty]

Ja. Ik kan je zo de hele oplossing geven.

Helaas is het een OEFENING. dus als ik het zou geven zou jij er niets van leren. Bedoeling van een oefening is dat jij het ZELF probeert op te lossen. Als iemand de oplossing geeft leer jij niets en kan je net zo goed die oefening niet doen.

[Orbit]

Op donderdag 26 april 2001 15:35 schreef dusty het volgende:
Ja. Ik kan je zo de hele oplossing geven.

Helaas is het een OEFENING. dus als ik het zou geven zou jij er niets van leren. Bedoeling van een oefening is dat jij het ZELF probeert op te lossen. Als iemand de oplossing geeft leer jij niets en kan je net zo goed die oefening niet doen.

Hetgeen ik vraag heeft toch niks met de oefening zelf te maken? Ik ben niet eens verplicht na te kijken of er wel de juiste gegevens worden ingegeven. Dat is een extraatje dat ik zelf wil toevoegen? En ik vraag toch geen volledige lap code? ik vraag gewoon of er iemand een id heeft van welke VOORGEDEFINIEERDE functie er bestaat die een invoer checkt of het wel degelijk een getal is.

[dusty]

Je antwoord staat in ctype.h

[Orbit]

Op donderdag 26 april 2001 15:59 schreef dusty het volgende:
Je antwoord staat in ctype.h

Ja?

de enige functie uit ctype die ik ken die aan de BIJNA aan de voorwaarden voldoet is isdigit(), maar die controleert maar 1 karakter en ik moet een volledig getal kunnen checken.

[The End]

Je kan bij chars ook zeggen:
char bla;
if((bla >= ''a'' && bla <= ''z'') || (bla >= ''0'' && bla <= ''9'') || (bla >= ''A'' && bla <= ''Z''))

[BC3 Victim]

Hier is een functie voor hele getallen (integers):

code:

BOOLEAN is_decimal_str(CHAR *str)
/****************************************************************************/
/* This function checks if a string represents a decimal number             */
/* The first character may also be a + or - sign                            */
/* ------------------------------------------------------------------------ */
/* Calling parameters:                                                      */
/*                                                                          */
/*  char pointer of the string.                                             */
/*                                                                          */
/* Return parameters:                                                       */
/*                                                                          */
/*  none.                                                                   */
/*                                                                          */
/* Function return value:                                                   */
/*                                                                          */
/*  TRUE if only numerical.                                                 */
/*                                                                          */
/****************************************************************************/
{
    INT_16  index = 0;
    BOOLEAN is_num = TRUE;

    while ((str[index] != '\0') && (is_num))
    {
        if (! isdigit(str[index]))
        {
            if ((index == 0) && (strlen(str) > 1))
            {
                if ((str[index] != '+') && (str[index] != '-'))
                {
                    is_num = FALSE;
                }
            }
            else
            {
                is_num = FALSE;
            }
        }

        index++;
    }
    return(is_num);
} /* is_numeric_str */

idigit() is een funtie die checked of een karakter een cijfertje is.

Volgende defines:

code:

typedef enum BOOLEAN
 {
  FALSE = (1!=1),
  TRUE  = (1==1)
 } BOOLEAN;

typedef char          CHAR;         /* charachter                        */
typedef void          VOID;         /* void function return              */
typedef float         FLOAT;        /* floating point                    */
typedef double        DOUBLE;       /* double precision                  */

typedef unsigned char UINT_8;       /* unsigned byte ( 8 bits)          */
typedef   signed char  INT_8;       /*   signed byte ( 8 bits)          */
typedef unsigned int  UINT_16;      /* unsigned word (16 bits)          */
typedef   signed int   INT_16;      /*   signed word (16 bits)          */
typedef unsigned long UINT_32;      /* unsigned long (32 bits)          */
typedef   signed long  INT_32;      /*   signed long (32 bits)          */

[The End]

Hehe blij dat ik niet zoveel in C schrijf.... Mag je niet in C++ schrijven?

[Infinitive]

Volgens mij doen jullie moeilijk:

// ------------------------
const char *array="35.1234";
// ------------------------

const char *ptr;
char c;
ptr = array; // ptr == &array[0];

while (((c = *ptr++) >= ''0'' && c <= ''9'') || c == ''.'');

if (c == NULL && ptr != array)
{it is a number!}
else
{it is not a number!}

// ------------------------

[Orbit]

Eerstejaars student hé, eers C en inleiding OO (C++ dus) Volgend jaar exclusief C++ (en ASP en Delphi en ...).

Maar niemand een oplissing?

[Orbit]

hmmmmm

das ni simpel zenne zo''n stukken code, ben eerstejaars hé. (en 0.0 ervaring in programmeren).

Maar ik heb ondertussen wel begrepen dat er geen functie is in de aard van isdigit() die gewoon checked of de ingegeven int wel degelijk een int is.

[BC3 Victim]

Moet je ook nog een functie voor floats hebben?

[Orbit]

nope enkel gehele getallen.

maar hoe kan ik uw lap code gebruiken, mijn array bestaat enkel uit int''s dus dan zit ik al met en typeconversie.

stom dat die isdigit geen groter broertje heeft.

ook stom dat ik niet zag dat isdigit() een char als variabele nodig heeft, dom, dom, dom

[BC3 Victim]

hiero:

code:

BOOLEAN is_float_str(CHAR *str)
/****************************************************************************/
/* This function checks if a string contains only numerical digits          */
/* The first character may also be a + or - sign; also one '.' may be in    */
/* the string.                                                              */
/* ------------------------------------------------------------------------ */
/* Calling parameters:                                                      */
/*                                                                          */
/*  char pointer of the string.                                             */
/*                                                                          */
/* Return parameters:                                                       */
/*                                                                          */
/*  none.                                                                   */
/*                                                                          */
/* Function return value:                                                   */
/*                                                                          */
/*  TRUE if only numerical.                                                 */
/*                                                                          */
/****************************************************************************/
{
    INT_16  index = 0;
    BOOLEAN is_float = TRUE;
    CHAR    *dot_ptr, *temp_str;
    UINT_16 pos;

    temp_str = (CHAR*) malloc(strlen(str));
    strcpy(temp_str, str);
    dot_ptr = strchr(temp_str, '.');

    if (dot_ptr)
    {
        if (strlen(temp_str) >= 2)
        {
            pos = dot_ptr - temp_str;
            temp_str[pos] = '\0';               /* make two strings of it */
            if (pos != 0)                       /* dot is not at the start */
            {
                is_float = is_decimal_str(temp_str);
            }
            if (pos != strlen(temp_str) - 1)   /* dot is not at the end */
            {
                index = pos + 1;
                while ((temp_str[index] != '\0') && (is_float))
                {
                    is_float = isdigit(temp_str[index]);
                    index++;
                }
            }
        }
        else
        {
            is_float = FALSE;
        }
    }
    else
    {
        is_float = is_decimal_str(temp_str);    /* no dot, must be integer */
    }

    free(temp_str);
    return(is_float);
} /* is_float_str */

Deze functie gebruikt het door mij al eerder geposte spul.

[The End]

Je moet geen int''s gebruiken bij de invoer, maar chars... Als iemand nu een ''a'' intypt kan je prog crashen...

[BC3 Victim]

Op donderdag 26 april 2001 16:20 schreef Orbit het volgende:
nope enkel gehele getallen.

maar hoe kan ik uw lap code gebruiken, mijn array bestaat enkel uit int''s dus dan zit ik al met en typeconversie.

Je kan met de functie is_decimal_str() kijken of de string een integer waarde bevat en zo ja, dan kan je de waarde converteren met atoi() naar integer. (staat in stdlib.h)

Gebruik dus een string als invoer van de gebruiker, check dan of die numeriek is, converteer dan naar int en dan kun je de int opslaan in je array.

[BC3 Victim]

Even een paar postjes terugkijken, daar heb ik een voorbeeldje toegevoegd op basis van jou progje

[Infinitive]

Moeilijkheidsgraad van code valt wel mee hoor... bovendien ben ik een nuldejaars want als alles goed gaat ga ik aankomend jaar informatica studeren. Over twee weken examen.

Desnoods plaats je deze functie boven je eigen code:

int isINT(const char *in)
{
const char *ptr;
char c;
ptr = in;

if (*ptr == ''-'')
ptr++;

while ((c = *(ptr++)) >= ''0'' && c <= ''9'');

if (c == NULL && ptr != in)
return 1;
else
return 0;
}

en roep je het aan met bijvoorbeeld:

if (isINT( ... ))
{
}

Bedenk wel dat het belangrijk is goed met arrays en loops te kunnen werken...

[BC3 Victim]

Op donderdag 26 april 2001 16:25 schreef Infinitive het volgende:

int isINT(const char *in)
{
const char *ptr;
char c;
ptr = in;

while ((c = *(ptr++)) >= ''0'' && c <= ''9'');

if (c == NULL && ptr != in)
return 1;
else
return 0;
}

Dit stukje code werkt niet in geval van negatieve getallen...

[Orbit]

Op donderdag 26 april 2001 16:23 schreef The End het volgende:
Je moet geen int''s gebruiken bij de invoer, maar chars... Als iemand nu een ''a'' intypt kan je prog crashen...

En hoe moet ik dan 512 ofzo invullen?

[Orbit]

Op donderdag 26 april 2001 16:32 schreef EXX het volgende:

[..]

Dit stukje code werkt niet in geval van negatieve getallen...

Das niet zo erg, negatieve getallen vliegen er zoiezo uit (de ints die ze invoeren zijn lengtes van telefoneren, dus da mag ni negatief zijn)

[Infinitive]

Dit stukje code werkt niet in geval van negatieve getallen...

Ow
Juist, zo meteen wel

Kijk nu maar boven... (wel bij de goede post kijken . Het enige waar nog niet op gecontroleerd wordt is op meer dan 1 punt...

[BC3 Victim]

Gebruik scanf("%s",str) voor het invoeren van een string, waarbij str een char array is van bv. 10 chars:

char str[10];

dus dan krijg je zoiets als:


char str[10];
int getal;

scanf("%s",str);
if is_decimal_str then getal = atoi(str)

En: ook al gebruik je geen negatieve waardes, het is toch makkelijk om daarop te apart kunnen checken. Je kunt dan de check op numeriek en negatief apart doen.

Overigens komt het stuk code uit een eigen gemaakt programma waar ik dus wel negatieve waardes moet kunnen verwerken, vandaar.

[Infinitive]

Wacht ff...

is het niet zo dat scanf uit zichzelf controleerd of de invoer wel een int is?? Want dan kan je gebruik maken van de return-code van scanf en heb je verder geen controle functie nodig.

if (!scanf( ...

[Orbit]

Op donderdag 26 april 2001 16:49 schreef EXX het volgende:
Bij de invoer met scanf een string invoeren en geen int.

Hmmm, als je de structuur van m''n programma bekijkt zie je dat dat niet echt simpel is hé. OF is er een eenvoudige manier?

[Infinitive]

Compileert ''ie wel? Heb ik geen tikfout gemaakt Ik heb even geen windows bij de hand om wat ik net getypt hebt te controleren.

En inderdaat je moet gebruik maken van iets als

char invoer[11];

fscanf("%10s", invoer);

Opmerking: fscanf gebruik ik nooit dus ik weet niet of wat ik hierboven gezet heb wel goed is...

[BC3 Victim]

Op donderdag 26 april 2001 16:56 schreef Infinitive het volgende:
Wacht ff...

is het niet zo dat scanf uit zichzelf controleerd of de invoer wel een int is?? Want dan kan je gebruik maken van de return-code van scanf en heb je verder geen controle functie nodig.

if (!scanf( ...

Ja, das een goeie. In mijn C boekje staat hetvolgende:

fscanf returns an EOF if end of file or an conversion error occurs before any other conversion; otherwirse it returns the number of input items converted and assigned.

en

scanf is nix anders dan fscanf(stdin,...

[Orbit]

Hmmm, dit word me echt wel iets TE ingewikkeld, ik denk dat het dan maar zonder testje zal moeten.

toch bedankt, ik zal nog een paar jaartjes oefening moeten hebben vrees ik.

[BC3 Victim]

Je kunt overigens de return code van scanf niet gebruiken. Run onderstaand progje maar eens en geef allerlei waardes in (zoals 1, a, en 1a), dan zul je het wel zien.

code:

#include    <stdio.h>

void    main()
{
    int waarde;
    int statuscode;

    statuscode = scanf("%d",&waarde);
    printf("waarde: %d statuscode: %d", waarde, statuscode);
}

Jammer dat je de input-check niet wil inzetten, het is echt niet zo moeilijk hoor.

- Eerst een string inlezen
- Kijken of de string een int bevat
- String ok: omzetten naar int en in de array opslaan.

[Verwijderd]

Waarom gebruik je niet gewoon de return value van scanf? Je laat gewoon een int inlezen, en test of de return waarde 1 is.

Uit man scanf:

RETURN VALUES
These functions return the number of input items assigned,
which can be fewer than provided for, or even zero, in the
event of a matching failure. Zero indicates that, while
there was input available, no conversions were assigned;
typically this is due to an invalid input character, such
as an alphabetic character for a `%d'' conversion. The
value EOF is returned if an input failure occurs before
any conversion such as an end-of-file occurs. If an error
or end-of-file occurs after conversion has begun, the num­
ber of conversions which were successfully completed is
returned.

<edit>
Ik weet dat dit al verschillende keren gezegd is, maar scanf() is gewoon de functie die hij zoekt.
</edit>

[BC3 Victim]

Nee! Zie mijn vorig geposte progje van een paar regels. scanf geeft nl. het aantal geconverteerde items terug. Als je bv.

rcode = scanf("%d", getal);

doet en je voert 123a56 in, dan komt in getal de waarde 123 te staan en is rcode gelijk aan 1. Dit komt omdat scanf toch een integer kan fabrieken; de conversie wordt gewoon afgebroken bij het eerste non-digit.
Je krijgt alleen nul terug als je invoer begint met een non-digit.

[Verwijderd]

Ff een aanvulling:

Als je maar op een variabele testen wilt, kun je die %[^0-9-] vervangen door een simpele %s. Dat scheelt een hoop tijd met het scannen, alles achter de int wordt dan in die string gedumpt.

Dus zoiets: ret= sscanf(blah,"%d%s",&val,buf);

<edit>dubbel woord</edit>

[BC3 Victim]

Op vrijdag 27 april 2001 15:50 schreef mietje het volgende:
ret= sscanf(blah,"%d %[^0-9-]",&val,buf);

Wow, dit soort constructies zijn nieuw voor mij; is dit werkelijk ANSI C? In mijn leerboek van ANSI C komt deze constructie niet voor en wordt ook niet uitgelegd. idem de help van Borland C. Zo zie je maar weer, je leert altijd wat nieuws op GoT! .

[Verwijderd]

Jep, die expressies tussen vierkante haken zijn ansi. Ze zijn zelfs door de ansi-comissie ingevoerd.

<edit>Ik quote man scanf maar ff:

[ Matches a nonempty sequence of characters from the
specified set of accepted characters; the next
pointer must be a pointer to char, and there must
be enough room for all the characters in the
string, plus a terminating NUL character. The
usual skip of leading white space is suppressed.
The string is to be made up of characters in (or
not in) a particular set; the set is defined by the
characters between the open bracket [ character and
a close bracket ] character. The set excludes
those characters if the first character after the
open bracket is a circumflex ^. To include a close
bracket in the set, make it the first character
after the open bracket or the circumflex; any other
position will end the set. The hyphen character -
is also special; when placed between two other
characters, it adds all intervening characters to
the set. To include a hyphen, make it the last
character before the final close bracket. For
instance, `[^]0-9-]'' means the set `everything
except close bracket, zero through nine, and
hyphen''. The string ends with the appearance of a
character not in the (or, with a circumflex, in)
set or when the field width runs out.

</edit>

[Verwijderd]

s