mein Problem ist das ich mit einer Parameter übergabe eine fehlermeldung kriege wenn ich Parameter aus einem Feld übergeben möchte.

Mein Programm sieht bisher so aus:

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
using namespace std;

class ebay {
private:
char artikel[30];
double istpreis;
int bezahlt;
char mail[30];
public:
int i;
ebay(char p=0,double y=0, int x=0, char c=0);
void ausgabe();

};

ebay::ebay(char p, double y, int x, char c){
for(i=0;i<30;i++){
artikel[i]=p;
mail[i]=c;
}
istpreis=y;
bezahlt=x;
}

//void ebay::bezahltstatus(){

// }

void ebay::ausgabe(){
for(i=0;i<30;i++){

if (artikel[i]<=-1)
continue;
cout << "\n'artikel[" << i << "] = " << artikel[i];
//cout << "\n'mail[" << i << "] = " << mail[i];
}
cout << "\n'Istpeis': " << istpreis;
cout << "\n'bezahlt': " << bezahlt;
}

int main(){
ebay verkauft[100] =
{
ebay( "Handy", 15.90, 1, "depp@gmx.de") , <-----ZEILE 57
ebay( "Staubsauger", 35.15, 0, "Hoppenstedt@web.de") ,
ebay( "Socken", 3.50, 0, "Manitu@fh-muenster.de")
};

cout << endl << endl;
system("pause");
return 0;
}

ich kriege diese fehlermeldung:

57 invalid conversion from `const char*' to `char'
57 initializing argument 1 of `ebay::ebay(char, double, int, char)'

private:
char artikel[30];
char mail[30];

public:
int i;
ebay(char p=0,double y=0, int x=0, char c=0);

int main(){    

    ebay( "Handy", 15.90, 1, "depp@gmx.de") ,               

}

Wie mein Vorredner schon sagte, obwohl der Compiler nur 2 Zeilen raushaut, liefert er das genaue Problem. Die compilerseitige Klarheit bedeutet allerdings nicht zwangsläufig Klarheit beim Programmierer. Selbst bei den "Profis" kommts manchmal vor, dass der Compiler die eigene Freundin sein könnte.

Habe deinen Code ein wenig zerpflückt:

In main rufst du mit ...
ebay( "Handy", 15.90, 1, "depp@gmx.de")

den Konstruktor auf ...
ebay(char p=0,double y=0, int x=0, char c=0);

Problem ist, die übergebenen Argumente "Handy" und "depp@gmx.de" sind Literale, genauer gesagt String-Literale oder konstante Zeichenketten vom Typ const char[6] und const char[12].
Jedes Zeichen einer solchen Zeichenkette wird garantiert direkt nebeneinander im Speicher abgelegt, wobei für jedes einzelne Zeichen ein Byte(char) beansprucht wird:
'H', 'a', 'n', 'd', 'y'

Hinzu kommt noch 1 Byte, um das Ende einer Zeichenkette zu markieren:
'\0'. Übergibst du ein String-Literal, brauchst dir darum allerdings keinen Kopf zu machen, dieses Zeichen wird dann automatisch angelegt.

Bei der Übergabe als Argument solcher Typen wird ein Zeiger auf das erste Element der Zeichenkette an den entsprechenden Parameter übergeben.

Nun sollen bei deinem Konstruktor die Parameter char p und char c anhand der übergebenen Argumente mit Zeigern auf const char[6] und const char[12] initialisiert werden. Autsch!
Eine Variable vom Typ char ist nicht dazu in der Lage, Zeiger aufzunehmen, sondern nur einen Wert(char wird meist dazu verwendet, um mit Zeichen zu hantieren), z.b.:
char p = 'a';

Ein Variable vom Typ char kann Informationen der Grösse 1 Byte "tragen", wohingegen ein Zeiger definitiv mehr Platz beansprucht, was wiederum abhängig vom System ist. Auf meiner 32 Bit Kiste benötigt ein Zeiger 4 Byte(32 Bit).

Damit die Parameter deines Konstruktors korrekt arbeiten, müssen diese angepasst werden. Einen Zeiger fängt man am besten mit einem Zeiger:

ebay(char* p,double y, int x, char* c);

Da ein String-Literal("Handy") konstant und unveränderbar ist, ist es noch besser und sicherer, die Parameter ebenfalls konstant zu erklären:

ebay(const char* p,double y, int x, const char* c);

Bei der Definition deines Konstruktors kannst du dann auf ein paar ältere Geschichten aus C zurückgreifen und dir die Schleife sparen:

[cpp]
ebay::ebay( const char* p, double y, int x, const char* c )
{
strcpy( artikel, p ); // sicherer ist strncpy, um nicht hinter Element 30 zu // schreiben
strcpy( mail, c );
}