Hier noch Code:
sample.h

#ifndef SAMPLE_H
#define SAMPLE_H

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

typedef class SAMPLE                  /* a sample */
{
private:
    int pack_iputw(int w, FILE *f);

public:
    unsigned short channels;           /* channels 1 or 2*/
    unsigned long sampleRate;          /* sample Rate (frequency)*/
    unsigned long bytesPerSecond;      /* bytes per second*/
    unsigned long len;                 /* length*/
    unsigned short bitsPerChannel;     /* bits*/
    void *data;                        /* sample data */

    SAMPLE(int bits, int stereo, int freq, int length);
    ~SAMPLE();

    void createSinWave(int freq);
    void createRectWave(int freq);
    void saveWav(const char* filename);
} SAMPLE;

#endif // SAMPLE_H

sample.cpp

#include "sample.h"

SAMPLE::SAMPLE(int bits, int stereo, int freq, int length)
{
//    printf("2. Bits: %d, Channels: %d, Freq: %d, Len: %d\n", bitsPerChannel, channels, sampleRate, len);
    bitsPerChannel = bits;
    channels = stereo;
    sampleRate = freq;
    len = length;

    data = malloc(len * 2/*((bits == 8) ? 1 : sizeof(short))*/ * stereo);
    if (!data) {
       delete this;
    }

    //printf("2. Bits: %d, Channels: %d, Freq: %d, Len: %d, Data: %d\n", bitsPerChannel, channels, sampleRate, len, (len * (bits/8) * stereo));
    printf("Done creating sample!\n");
}

SAMPLE::~SAMPLE()
{
    if(data)
    {
        free(data);
    }
}

// creates a rectagular wave
void SAMPLE::createRectWave(int freq)
{
    printf("Start creating RectWav!\n");

    memset(data, 0x8000, len *2 );

    if (freq == 0) {
        return;
    }
    int dist  = sampleRate / freq;
    int dist2 = dist/2;
    int count = len / dist +1;

    for (int a=0; a < count; a++) {
        for (int b=0; b < dist; b++) {
            if ( (unsigned) (a*dist+b) >= len)
            {
                printf("Done creating RectWav!\n");
                return;
            }
            if (b < dist2)
            {
                ((signed short*)data)[a*dist+b] = 0xffff;
            }
            else
            {
                ((signed short*)data)[a*dist+b] = 0x0000;
            }

        }
    }
}

// to be ignored for now
// creates a sin wave
//void SAMPLE::createSinWave(int freq)
//{
//    for (unsigned int i=0; i<len; i++)
//        ((signed short*)data)[i] = 1 * sin(2*M_PI*freq*i);
//}

// writes the SAMPLE data into a .WAV file
void SAMPLE::saveWav(const char *filename)
{
    if (!data)
    {
        printf("Could not save data to %s, nothing passed.\n", filename);
        return;
    }

    FILE* file = fopen(filename, "wb");

    if (file)
    {
        // initialize wave header
        unsigned short formatType = 1;
        unsigned short numChannels = channels;
        unsigned long sampleRate = this->sampleRate;
        unsigned short bitsPerChannel = this->bitsPerChannel;
        unsigned short bytesPerSample = numChannels * (bitsPerChannel / 8);
        unsigned long bytesPerSecond = sampleRate * bytesPerSample;
        unsigned long dataLen = len*bytesPerSample;

        const int fmtChunkLen = 16;
        const int waveHeaderLen = 4 + 8 + fmtChunkLen + 8;

        unsigned long totalLen = waveHeaderLen + dataLen;

        // write wave header
        fwrite("RIFF", 4, 1, file);
        fwrite(&totalLen, 4, 1, file);
        fwrite("WAVE", 4, 1, file);
        fwrite("fmt ", 4, 1, file);
        fwrite(&fmtChunkLen, 4, 1, file);
        fwrite(&formatType, 2, 1, file);
        fwrite(&numChannels, 2, 1, file);
        fwrite(&sampleRate, 4, 1, file);
        fwrite(&bytesPerSecond, 4, 1, file);
        fwrite(&bytesPerSample, 2, 1, file);
        fwrite(&bitsPerChannel, 2, 1, file);

        // write data
        fwrite("data", 4, 1, file);
        fwrite(&dataLen, 4, 1, file);
        //fwrite(data, dataLen, 1, file);

        /* write the data */
        if (bitsPerChannel == 8) {
            fwrite(data, dataLen, 1, file);
        } else {
            signed short s;
            for (int i=0; i < (int)len * numChannels; i++) {
                s = ((signed short *)data)[i];
                pack_iputw(s^0x8000, file);
            }
        }

        // finish
        printf("Saved audio as %s\n", filename);
        fclose(file);
    }
}

/* pack_iputw:
 *  Writes a 16 bit int to a file, using intel byte ordering.
 */
int SAMPLE::pack_iputw(int w, FILE *f)
{
   int b1, b2;

   b1 = (w & 0xFF00) >> 8;
   b2 = w & 0x00FF;

   if (fputc(b2,f)==b2)
      if (fputc(b1,f)==b1)
         return w;

   return EOF;
}

aufgerufen wir das ganze so:

SAMPLE *sample = new SAMPLE(16, 2, 44100, 44100);
    if(sample)
    {
        sample->createRectWave(440);
        sample->saveWav("test.wav");
    }

    delete sample;

typedef class SAMPLE

Vielleicht mag mir jemand diese Zeile erklaeren ...

Ich würde bei Einbindung von <irgendwas.h> Headern, Benutzung von malloc/free, sprintf, memset, FILE und typedef class SAMPLE { /* whatever */ } SAMPLE; eher auf C (das ich nicht so recht kann) schließen. Vielleicht Forum verfehlt?

Das dachte ich auch und ich hätte es auch ohne zu zögern verschoben, aber dann ist mein Blick doch kurz an der sample.h hängengeblieben, wo er doch so etwas macht was man als C++ bezeichnen könnte. Es ist jedenfalls die ungewöhnlichste C/C++-Mischung die ich je gesehen habe. RAII mit malloc/free ist mal was ganz Neues.

...

Wenn es Dir um das bloße erstellen einer WAV-Datei geht:
Ich würde die Samples erstmal in eine Floatingpointformat erstellen, und erst vor dem Speichern in die Datei quantisieren.

Das sich bei 8 Bit die Frequenz halbiert liegt daran, dass Du sie als short int (16 Bit) erzeugst und dann weg schreibst. Du speicherst also doppelt so viele Samples weg wie vorhanden. Dass das so überhaupt noch ein brauchbares ergebnis liefert liegt daran, dass Du ein Rechtecksignal mit 0xFFFF als max. Amplitude hast.

Bei Stereo hingegen legst Du zwar (soweit ich das blicke) einen ausreichend großen Puffer an, jedoch befüllst Du nur die Hälfte davon und schreibst auch nur die Hälfte in die Datei. Irgendwie so.

Ich kann den Code auch gerne in das C Forum posten, ich dacht nur dann würde ich doch wegen doppelpostens angekreidet werden. Außerdem will ich ja die Klassen etc. behalten. Auf malloc, free und memset würde ich am liebsten verzichten, nur weiß ich nicht so genau wie ich das mit new hinkriege. Also wenn ihr mir da helfen könnt wär echt super. Eine Alternative zu memset kenn ich auch nicht. Das mit dem printf benutze ich ja nur für debug ausgaben und das auch nur weil ich das noch so gewöhnt bin... FILE hab ich deshalb benutzt, weil ich mit C++ noch keine Erfahrung im Filehandeln hab und deshalb erst mal das gewohnte von C nehmen wollte. Das mit dem typedef seh ich jetzt auch, das das bescheuert war
Vielen Dank, Foaly

Edit 1: Oh da war ja noch ein Post. Ja also ich hab ja verstanden, das ich die Daten falsch allokiere. Könntet ihr mir sagen wie ich das am besten mache, das ich ein Floatingpointtyp nehme und dann mit new erstelle?