Hi Leute,

habe jetzt schon länger mit C nichts mehr gemacht und deshalb bin ich mir jetzt etwas unsicher.

Also ich habe ein paar ganz kleine Algorithmen die ich kurz erklären möchte.

int[] algA (int j) {
int[] myAr = new int[6];
myAr[0] = j;
myAr[1] = myAr[0] * j;
myAr[2] = myAr[1] * j;
myAr[3] = myAr[2] * j;
myAr[4] = myAr[3] * j;
myAr[5] = myAr[4] * j;
return myAr;
}

Hier wird ein Array mit 6 (0-5) Speicherzellen definiert. Und jede bekommt als Wert das Quadrat der vorherigen zugewiesen.
Ausgegeben wird die 6 oder? Bin mir gar nicht sicher.

int[][] algB (int i) {
int[][] myAr = new int[3][3];
myAr[0][0] = i;
myAr[1][0] = i * i;
myAr[2][0] = i * i * i;
i = i + 1;
myAr[0][1] = i;
myAr[1][1] = i * i;
myAr[2][1] = i * i * i;
i = i + 1;
myAr[0][2] = i;
myAr[1][2] = i * i;
myAr[2][2] = i * i * i;
return myAr;
}

Hier werden die Multiplikationen den einzelnen Arrays zugewiesen. Aber welchen Sinn macht die Ausgabe?

int algC (int i) {
int result = 0;
if (i == 0)
result = 0;
if (i < 0)
result = -1;
if (i > 0)
result = 1;
return result;
}

Also bei Eingabe i=0=Ausgabe, Eingabe kleiner also 0, dann wird -1 ausgegeben, bei Eingabe>0 wird 1 ausgegeben.

Betrachten Sie nur Eingabewerte k > 0.
int[] algD (int k){
int[] bar = new int[k];
for (int i = 0; i < k; i++) {
bar[i] = i * i;
}
return bar;
}

Hier wird ein Array mit k bzw. i Zellen definiert und jeder wird das Quadrat von i zugewiesen, also Zelle 1 wird 1*1=1 zugewiesen, der 2. Zelle 2*2=4 usw...
Was return bar ausgibt weiß ich nicht, wie bei dem 1. Code.
Oder wird damit einfach der neue Inhalt vom Array bar an die Hauptfunktion zurückgegeben?

int algE (int[] k){
int a = 0;
int res = 0;
while (a < k.Length) {
res = res + k[a];
a = a + 1;
}
return res;
}

Hier haben wir das Array k mit a Elementen und der Inhalt von allen Elementen wird summiert und ausgegeben, richtig?
k.Length steht ja für die Anzahl der Elemente in array k.

Gibt es einen Befehl der mir ein Array invertiert?
Also z.B. aus [1, 2, 3, 4, 5] dann [5, 4, 3, 2, 1] macht?

Dann noch etwas kurz zu booleschen Werten.
Ich habe 2 Tabellen für die ich einen Algorithmus schreiben will, aber ich weiß nicht was das für boolesche Funktionen sind.
Der dritte Wert ist immer die Ausgabe.

1.
false, false, false
false, true, false
true, false, false
true, true, false

2.
false, false, true
false, true, false
true, false, true
true, true, true

Bei 1. kann ich doch einfach immer false ausgeben lassen??
Bei 2. fällt mir zur Zeit gar nichts ein.

Vielen Dank für´s Lesen!

Danke dir, habs dann mit paar Veränderungen hinbekommen.

Ich habe jetzt durch Tipps und das Tutorial Pronix das hier:

Zitat

int main(int argc,char*argv[])
{
double val1,val2;
char op;

if(argc!=3)
{
printf("Fehler - bitte Parameter 'calcul + 5.1 6.2' angeben");
return 1;
}

op=argv[1][0];
val1=atof(argv[2]);
val2=atof(argv[3]);

printf("%f",val1+val2);

return 0;
}

Alles anzeigen

argc ist die Anzahl der übergebenen Parameter, argv[1] der Operator (z.b. +), argv[2] und argv[3] die beiden Operanden.

Wenn ich das so laufen lasse, dann bekomme ich die die Fehlermeldung ausgegeben und fertig.
Aber was muss ich machen/hinzufügen,dass ich das auch eingeben kann?
Also z.b.: calcul + 2 3

gelbasack

Danke für den Hinweis. Wenn ich & weglasse bekomme ich die Fehlermeldung "op is used without being defined".

MickeyM

Ja das wäre natürlich die einfachste Lösung. Aber wir müssen das als Zeichenkette einlesen.

Zitat

Aufgabenstellung:
Es sollen arithmetische Ausdrücke in den vier Grundrechenarten berechnet werden. Operator und Argumente werden als Kommandozeilenargumente angegeben.
Zur Umwandlung einer Zeichenkette in einen double Wert kann die Funktion atof() verwendet werden.

Hi Leute,

ich muss ein kleines Programm schreiben das wie folgt funktionieren soll:

Eingabe: calcul + 5.1 6.2

Ich nehme mal an, dass er mir die beiden Zahlen addieren soll.
Jedoch müssen diese ja in einer Zeile eingegeben werden, also String.

Jetzt kenne ich die Funktion atof die mir jetzt die 5.1 "rausholen" kann. Aber wie mache ich das mit der 6.2 ?

Bin mit Hilfe von jemanden darauf gekommen, dass man alles einzeln als string einlesen kann.

#include <stdlib.h> 
 #include <stdio.h> 

 void main (void) 
 { 
   double zahl1,zahl2; 
   char *string1; 
   char *string2; 
   char *op; 

 scanf("%s",&op); 
 scanf("%s",&string1); 
 scanf("%s",&string2); 



   zahl1 = atof (string1); 
   zahl2 = atof (string2); 
   printf ("%f", zahl1+zahl2); 

 }

Wenn ich das laufen lasse, dann gebe ich z.b. ein + 5 2.
Und dann wird der Debuger wegen einer "unbehandelten Win32 Ausnahme" gestartet.

Ich nehme an, dass ich etwas bei der scanf Adressierung falsch mache. Kann mir jemand helfen?

Vielen Dank!

Ich habe mal die Funktion zur Berechnung iterativ geschrieben und mit einer Abfrage.

unsigned int fibonacci(int n)
{ int x=1, y = 1, i, sum=0;
  for (i=2; i<=n; i++)
  {
      if (sum > INT_MAX-x)
      {
        printf("Fehler\n");
        return 0;
      }


    sum = x + y;
    x = y;
    y = sum; 
  }
  return y;
}

Hab jetzt diesen Beitrag hier editiert, weil es etwas durcheinander wurde.

Ich glaube, dass es jetzt so richtig ist.
Zuerst hatte ich in der If-Abfrage UINT_MAX. Da hatte ich das Problem, dass bei der Eingabe 46 (also dass die 46. Fibonacci Zahl ausgegeben werden soll) eine negative Zahl ausgegeben wurde. Und erst ab der Eingabe 47 der "Fehler" ausgegeben wurde.
Die negative Ausgabe liegt wahrscheinlich daran, dass da schon der Überlauf stattgefunden hat und das Überlaufbit gesetzt wurde.

Nachdem ich jetzt INT_MAX genommen habe, bekomme ich schon ab der 46 die "Fehlermeldung".

Ich hoffe dass das jetzt so richtig ist...

Zitat von hal

Interessante Tabelle, das ist nämlich überhaupt nicht standardisiert. Das einzige was fix ist ist, dass "int" der Bitbreite des Prozessors entspricht (also 8bit bei einem 8bit-Prozessor, 16bit auf einem 16bit-Prozessor, 32bit bei einem 32bit-Prozessor und 64bit bei einem 64bit-Prozessor), und dass char die kleinste addressierbare Einheit (üblicherweise 1 Byte) ist.
Die Tabelle kann also nur für genau einen Compiler auf genau einer Plattform sein, was vermutlich nicht deiner Plattform entspricht.

Das höchste Bit einer Zahl kannst du bestimmen, indem du eine Schleife machst:

Code

for(unsigned int i = sizeof(zahl)*8; i; i--)
  if(zahl & (1 << i)) {
    printf("Höhstes Bit ist %u\n",i);
    break;
  }

Oder so in der Art (könnte wieder einen off by one-Fehler enthalten, um sowas zu kontrollieren bin ich nimmer nüchtern genug ;)).

Danke, dass du dich da noch gequält hast *g*

Die Tabelle bzw. Info habe ich aus dem Pronix C Tutorial.

Ich habe die for-Schleife vor das return 0 eingebaut und es kamen folgende Meldungen.

\fibo.c(15) : warning C4996: 'scanf' wurde als veraltet deklariert
        c:\programme\microsoft visual studio 8\vc\include\stdio.h(295): Siehe Deklaration von 'scanf'
        Meldung: "This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_DEPRECATE. See online help for details."
\fibo.c(19) : error C2143: Syntaxfehler: Es fehlt ';' vor 'Typ'
\fibo.c(19) : error C2143: Syntaxfehler: Es fehlt ';' vor 'Typ'
\fibo.c(19) : error C2143: Syntaxfehler: Es fehlt ')' vor 'Typ'
\fibo.c(19) : error C2143: Syntaxfehler: Es fehlt ';' vor 'Typ'
\fibo.c(19) : error C2065: 'i': nichtdeklarierter Bezeichner
\fibo.c(19) : error C2143: Syntaxfehler: Es fehlt ';' vor ')'
\fibo.c(22) : error C2043: Schlüsselwort 'break' ungültig
\fibo.c(24) : error C2059: Syntaxfehler: 'return'
fibo.c(25) : error C2059: Syntaxfehler: '}'

Kann man die Bedingung "i" einfach alleine stehen lassen?

Ich habe mal ausgeben lassen:

printf("%d",sizeof(zahl));

Und da kommt immer 4 raus, d.h. dass unsigned int 4 Bytes hat? Hab gedacht 2 (laut meiner Tabelle).

Wie kann man dann die Bits bzw. Bytes des Ergebnisses bestimmen um zu "sagen" es werden mehr benötigt ?

Danke euch für die Antworten.

Ein unsigned int hat ja 2 Bytes, 16 Bits. Also von 0...65535.
Was mich grad verwirrt ist, dass wenn ich mein Programm laufen lasse und eingebe, dass mir die 30. angezeigt werden soll, dann kommt 832040.
Wo liegt mein Denkfehler??

Und die Abfrage kann ich dann so machen?

if (sizeof(zahl)>16)
{
printf("Nicht darstellbar");
}

Hi Leute,

ich bin dabei ein Programm zu schreiben, das mir Fibonacci Zahlen berechnet.
Das "Hauptprogramm" habe ich geschafft.
Jedoch soll ich bei dem Programm die größte darstellbare Zahl bei dem verwendeten Datentyp beachten und es soll eine Fehlermeldung ausgegeben werden, wenn diese "zu groß" ist.

Das hat etwas mit dem sizeof Operator zu tun, oder? Habe mit ihm noch nie so gearbeitet bzw. so einen Aufgabentyp.

Mein Fibonacci Programm sieht so aus:

#include <stdio.h>
#include <limits.h>






int main(void) {
    unsigned int zahl;


    printf("Bitte eine positive ganze Zahl eingeben: ");
    scanf("%d", &zahl);
    printf("Die %d. Fibonaccizahl ist %ld\n",
       zahl, fibonacci(zahl));
    return 0;
}

Wie mache ich das mit der "größten darstellbaren" Zahl?

Vielen Dank!!

Ja das stimmt, ist nicht wirklich sauber, was mich auch stört.

ich habe deshalb in der messwert.c noch die funktion double einlesen(int anzahl) definiert und läuft jetzt auch so.

Danke nochmal!

Kleine Frage zu einem Programm wo ich sagen soll was für eine Bildschirmausgabe es bewirkt.

#include <stdio.h>


int a=1, b=2, c=3, d=4, e=5, f;


int wertzuweisungen(int a)
{ 
int c, e;


a = 11;
b = 12;
c = 13;
d = 14;
e = 15;


return d;
}




main()
{ 
int d, g;


a = 21;
b = 22;
c = 23;
d = wertzuweisungen(c);


printf("%2d %2d %2d %2d %2d %2d %2d", a, b, c, d, e ,f, g);
}

Wenn ich es so übernehme bekomm ich einen Fehler, weil g[/d] keine Zuweisung bekommen hat.
Ich nehme mal an, den Fehler hat der prof ausversehen gemacht.
Ich habe dann mal einfach für g=0 gesetzt.

Meine Bildschirmausgabe ist dann
[b]21 12 23 14 5 0 0 wobei die letzte Null ich ja so gesetzt habe.

Jetzt frage ich mich was soll dabei so besonders sein, bei der Ausgabe?
Sieht das jemand?

Danke für den Tipp. ich hab double messwert[20]; in der messwert.c gelassen und zusätzlich extern double messwert[20]; in die messwert.h reingeschrieben. Jetzt kann ich auch in der main.c drauf zugreifen.

Normal habe ich die messwert[20]; in der main.c nur wegen der Eingabe der Zahlen gebraucht. Aber die macht ja jetzt die double mittel am anfang.
So erspare ich mir eine weitere int Variable in der main.c.

nochmal wegen den Variablen i, s und m. Die brauche ich in beiden Funktionen, also double mittel und double abweichung. Deshalb hab ich sie global. oder meintest es anders?

Danke!

So einen Fehler hatte ich schon mal bei einem anderen Programm...

Jetzt geht es aber.

Wegen den Variablen i, anzahl, s und m. Wo soll ich sie dann definieren?

und extern mittelwert[20]; kann ich in messwerte.h schreiben und double messwert[20]; in messwerte.c lassen?

Weil ich bekomme die Meldung:
'messwert': Neudefinition; unterschiedliche Basistypen

Hallo,

danke für die Erklärungen.

Ich hab eben gesehen was du meinst, hab schon geahnt es liegt an den Variablen.

Jetzt habe ich um es mir zu erleichtern die Eingabeschleife

for (i=0;i<anzahl;i++)
{
    scanf("%f", &messwert[i]);
}

aus main.c rausgenommen und in messwerte.c in die double mittel Funktion eingefügt.

Dann habe ich in main.c für die Eingabe der Anzahl der Zahlen die Variable x genommen.
Diese wird dann der mittel Funktion in messwerte.c übergeben. Entsprechend habe ich dann die Funktionen verändert.

double mittel(int anzahl)
double abweichungl(int anzahl)

Somit wird ja x der Variablen anzahl übergeben.
messwert[i] sind die Zahlen die eingegeben/eingelesen werden.

Dann habe ich wieder durchlaufen lassen und meine 4 Zahlen eingegeben: 4, 5, 6, 5.

Aber bekomme leider 0.00000 raus, beim Mittelwert, als auch der Abweichung...

Hier nochmal die veränderten Dateien
main.c

#include <stdio.h>
#include <math.h>
#include "messwerte.h"








int main()
{
int x;
double a, mittelwert;




printf("Anzahl der Messwerte eingeben: ");
scanf("%d", &x);


printf("Geben Sie die %d Messwerte ein: ", x);


mittelwert=mittel(x);
a=abweichung(x);


printf("Mittelwert: %f\n", mittelwert);
printf("abweichung %f\n",  a);

messwerte.c

#include "messwerte.h"
#include <math.h>


double s=0, m=0;
int i,anzahl;
double messwert[20];


double mittel(int anzahl)
{
for (i=0;i<anzahl;i++)
{
    scanf("%f", &messwert[i]);
}


for (i=0;i<anzahl;i++)
    {
    m=m+messwert[i];
    }
m=m/anzahl;
return m;
}




double abweichung(int anzahl)
{
for(i=0;i<anzahl;i++)
    {
    s=s+(messwert[i]*messwert[i]-2*messwert[i]*m+m*m);
    }


s=sqrt((1.00/anzahl)*s);
return s;
}

messwerte.h

#ifndef MESSWERTE_H
#define MESSWERTE_H


double mittel(int anzahl);
double abweichung(int anzahl);


 #endif

Was stimmt noch nicht?

Jetzt habe ich doch noch ein Problem.

Und zwar muss ich die Funktionen zur Berechnung des Mittelwertes mittel(anzahl) und der Abweichung abweichung(anzahl) in eine headerdatei speichern.

Ich habe das schon mal gemacht bei Vektoraufgabe. War aber etwas anders.

Ich habe also drei Dateien
main.c
messwerte.c (die Funktionen)
messwerte.h (die Funktionsdeklarationen)

in messwerte.c habe ich

#include "messwerte.h"
#include <math.h>


float s=0, m=0, n;
int i,anzahl;
float messwert[20];


float mittel(int i)
{
for (i=0;i<anzahl;i++)
    {
    m=m+messwert[i];
    }
m=m/anzahl;
return m;
}


float abweichung(int i)
{
for(i=0;i<anzahl;i++)
    {
    s=s+(messwert[i]*messwert[i]-2*messwert[i]*m+m*m);
    }


s=sqrt((1.00/anzahl)*s);
return s;
}

messwerte.h

#ifndef MESSWERTE_H
#define MESSWERTE_H


float mittel(int i);
float abweichung(int i);


#endif

main.c

#include <stdio.h>
#include <math.h>
#include "messwerte.h"


int main()
{




float a, m;
int i,anzahl;
float messwert[20];






printf("Anzahl der Messwerte eingeben: ");
scanf("%d", &anzahl);




printf("Geben Sie die %d Messwerte ein: ", anzahl);


for (i=0;i<anzahl;i++)
{
    scanf("%f", &messwert[i]);
}
m=mittel(anzahl);
a=abweichung(anzahl);




printf("Mittelwert: %f\n", m);
printf("abweichung %f\n",  a);
}

Wenn ich das in Visual Studio eingebe läuft das Programm zwar, aber bekomme beim Mittelwert und bei der Abweichung mit meinen Zahlen -1.#IND00 raus was ja nicht richtig ist.

habe ich bei den Definitionen in der messwerte.h oder messwerte.c was vergessen?

Danke für deinen Tipp!

Es hat ausgereicht die 1 in 1.00 im Zähler zu schreiben.

Und dann war ausschlaggebend, dass ich in der Funktion ganz oben den Mittelwert m nicht zurückgegeben habe, also return m.

Jetzt läuft es prima!

Danke nochmal!

Hallo Leute,

habe gerade ein Programm fast ganz fertig bekommen.
Es soll den Mittelwert von x eingegebenen (maximal 20) float Werten ausgeben und die Standardabweichung.

Der Mittelwert wird richtig ausgegeben, aber bei der Abweichung bekomme ich irgendwie -1.#IND00.
Als Testdaten habe ich 4 Werte eingegeben, und zwar 4, 5, 6, 5.
Mittelwert: 5 stimmt
Abweichung müsste 0.707 sein, aber kommt wie gesagt nicht raus.

Die Formel für die Abweichung ist ja wie hier
http://de.wikipedia.org/wiki/Geometrische_Standardabweichung

Das zweite x mit dem Oberstrich steht ja für den Mittelwert.

Was mache ich falsch? Alles scheint zu funktionieren bis auf das mit der Berechnung der Abweichung. Habe ich da einen Fehler?

Hier mal mein Quellcode:

#include <stdio.h>
#include <math.h>


float s, m, n;
int i,anzahl;
float messwert[20];








float mittel(int i)
{
for (i=0;i<anzahl;i++)
{
    scanf("%f", &messwert[i]);
}




for (i=0;i<anzahl;i++)
{
    m=m+messwert[i];
}
m=m/anzahl;
printf("Mittelwert: %f\n", m);


}


int main()
{
s=0;




printf("Anzahl der Messwerte eingeben: ");
scanf("%d", &anzahl);




printf("Geben Sie die %d Messwerte ein: ", anzahl);
m=mittel(anzahl);


[B]
for(i=0;i<anzahl;i++)
{
    s=s+((messwert[i]-m)*(messwert[i]-m));
}
s=sqrt((1/anzahl)*s);




printf("abweichung %f",s);
[/B]
}

VIelen Dank fürs Lesen!

Ich habe etwas herumgesucht und habe bei Wikipädia bisschen was rausgefunden...

Und zwar bekomme ich die Adresse von sum, indem ich die Ausgabe von sum so verändere

printf("Summe: [b]%p[/b]\n", [B]&[/B]sum);

So bekomme ich bei der Ausgabe 0012FF18.

Wird das gemeint?

Hallo Leute,

hab eine "kleine" Aufgabe die ich nicht so ganz verstehen kann.

Geben Sie das Speicherabbild des folgenden Programms vor Aufruf von printf() an.

#include <stdio.h>
  main()
{  double vek[3] = { 1.2, 3.0, 5.2 };
   double *v0 = &vek[0];
   double *v1 = &vek[1];
   double *v2 = &vek[2];
   double sum;
     sum = *v0 + *v1 + *v2;
   printf("Summe: %f\n", sum);
   return 0;
}

Hinweis: Die Adressen der Variablen lassen sich durch geeignete Ausgabeanweisungen bestimmen.

Ich verstehe nicht wirklich was gemeint wird. Um das Ergebnis zu kennen brauche ich ja nicht unbedingt printf, denn das sieht man ja so.

Oder geht es speziell um die Speicherstellen der Variablen? Ich verstehe das irgendwie nicht...

Vielen Dank fürs Lesen!

Ah danke für den Hinweis! Jetzt ist es einwandfrei!

Danke nochmal!!