Funktion, die 2 Variablen addiert, wenn es kein negatives Ergebnis gibt

OP #1816980
Lesenswert?

Hallo

Ich würde gerne um meinen Code zu halbieren eine Funktion schreiben, die 
2 Variablen addiert und das aber nur tut wenn das ergebniss nicht 
negativ ist. Nur ich will, dass ich sowohl 8bit, als auch 16bit und 
32bit Variablen nutzen können. Auerßdem ist die erste Var immer 
unsigned.

Meine Idee wäre sowas:
1
void Add(uint32_t* source, int32_t* add)
2
{
3
    if((int64_t)*source + *add > 0)
4
        *source += *add;   
5
}

Allerdings kann man da doch nur int32_t übergeben und ich glaube auch, 
dass sie nicht ganz funktioniert.
Gast #1817007
Lesenswert?

Ich würde es so machen, wenn es für alle Datentypen gehen soll:

1
#include <stdint.h>
2

3
uint32_t
4
SpecialAdd(uint32_t source, int32_t add)
5
{
6
    int64_t tmp = (int64_t)source + add;
7

8
    if( (tmp >= 0) && (tmp <= UINT32_MAX) )
9
    {
10
       return( (uint32_t)tmp );   
11
    }
12
    else
13
    {
14
       return( source );
15
    }
16
}
OP #1817017
Lesenswert?

Stimmt so würde es gut gehen.

Man kann doch in C auch so etwas machen oder?
1
void Add(...)
2
{
3

4
}

Damit könnte man doch Argumente übergeben, die unbekannt sind. Außerdem 
könnte man dann doch mit sizeof die Größe bestimmen und dann die 
Addition auc nicht zulassen wenn z.b. ein 16bit Wert übergeben wurde.

EDIT: oder war das nur c++?

EDIT2: Würde sowas gehen?:
1
uint32_t Add(uint32_t source, int32_t add, uint8_t size)
2
{
3
    int64_t tmp = (int64_t)source + add;
4
    if(tmp > 0 && tmp < ((uint64)1 << size)
5
        return tmp;
6
    else
7
        return source;
8
}
OP #1817254
Lesenswert?

Ich hätte da noch eine Idee. In c# kann man meines Wissens so was 
machen:
(Jetzt mit den µC Variablen, in c# würde es statt int32 natürlich int 
und statt int64 long heißen).

T Add<T>(T source, int32 add)
{
    int64_t tmp = (int64_t) source + add;
    if(tmp > 0 && tmp < (1 << sizeof(T)))
        return tmp;

}

Das würde man dann so aufrufen: uint16_t zahl = Add<uint16_t>(100, -50);
Gast #1817262
Lesenswert?

Samuel K. schrieb:
> Damit könnte man doch Argumente übergeben, die unbekannt sind. Außerdem
> könnte man dann doch mit sizeof die Größe bestimmen und dann die
> Addition auc nicht zulassen wenn z.b. ein 16bit Wert übergeben wurde.
nein das geht so nicht, weil sizeof zur compilezeit ermittelt wird. Bei 
einer Variabelen argumentenliste kann man überhaupt nichts mehr 
bestimmen.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren