Jak sjednotit string v poli? – C / C++ – Fórum – Programujte.com

Zdravim mam takovej problem potrebuju udelat sjednoceni prvku v mnozine.

Main se nesmi vubec menit... Za kazdou radu budu moc vdecnej potrebuju to dodelat do  vikendu a nejak mi tohle nejde...

#include <iostream>
#include <cstdlib>
using namespace std;

class Mnozina
{
	int pocet;
public:
	string prvky[20];
	Mnozina();
	Mnozina(int);
	Mnozina operator+ (Mnozina Sjednoceni);
	Mnozina operator- (Mnozina Rozdil);
	Mnozina operator* (Mnozina Prunik);
	void vypis();
	
};

Mnozina::Mnozina(int pocet)
{
	int poradi = 1;
	for(int n = 0; n < pocet; n++)
	{
		cout << "Prvek " << poradi << "/" << pocet << ": "; 
		cin >>prvky[n];
		poradi++;
	}
}

Mnozina::Mnozina()
{
	prvky[20];
}

void Mnozina::vypis()
{
	for(int n = 0; n < 20; n++)
	{
		cout << prvky[n] << " ";
	}
}

int main (int argc, char *argv[]) 
{
	if ( argc != 3) 
	{
		cout << "Program chce dva short parametry" << endl;
		return 1;
	}	
	cout << "Zadavejte prvky pro mnoziny a a b" << endl;
	Mnozina a(atoi(argv[1])); Mnozina b(atoi(argv[2]));
	Mnozina c, d, e, f;
	cout << "Prvky a: "; a.vypis() ; cout << endl;
	cout << "Prvky b: "; b.vypis() ; cout << endl;
	cout << "* Sjednoceni c=a+b : ";
	c=a+b; c.vypis(); cout << " -" << c.getVelikost() << endl;
	cout << "* Prunik d=a*b : ";
	d=a*b; d.vypis(); cout << " -" << d.getVelikost() << endl;
	cout << "* Rozdil e=a-b : ";
	e=a-b; e.vypis(); cout << " -" << e.getVelikost() << endl;
	cout << "* Rozdil f=b-a : ";
	f=b-a; f.vypis(); cout << " -" << f.getVelikost() << endl;
	return 0;
}

#1 Mory
místo pole stringů použij std::vector<std::string>

A co si představuješ, že bude výsledkem průniku řetězců? Když budou stejné tak ten řetězec a když budou různé, tak "" nebo něco na úrovni znaků?

A co sis myslel tímto?: 

Mnozina::Mnozina()
{
	prvky[20];
}

No ucelem je ze po spusteni zadam prvky do Mnozina a, a pote do Mnozina b. Pak prave potrebuju kde je c = a + b aby ty dve mnoziny sjednotil do mnoziny c... kde vlastne budou vsechny prvky...

Mnozina::Mnozina()
{
	prvky[20];
}

No a popravde tohle ani nevim proc tam mam... to jsem tam nejspis dal aby na me nevyskocila chyba kdej jsem testoval zacatek... Nevim si s tim moc rady

Počet prvků musíš dynamicky nastavovat, takže žádné string prvky[20];, ale hezky alokovat pole stringů (new) nebo používej vector, jak ti radil crazy.

No a sjednocení tedy bude ve 2 cyklech. V prvním překopíruješ do výsledné množiny (c) obsah a a v druhém do toho výsledného překopíruješ obsah druhé množiny. Velikost množin je samozřejmě je její vlastnost, takže žádných 20, ale pocet (který bys asi měl vracet i v getVelikost). A ten nesmysl můžeš z implicitního konstruktoru smazat.

Jo dobre... Tak ja to teda nejak zkusim snad na to prijdu zatim diky.

Je mozny aby to bylo nejak takhle? Jeste to neni uplne dodelane zadani funguje a vypise mi to mnozinu a ale u b to vyhodi chybu tak mi tam nejspis neco chybi...

#include <iostream>
#include <cstdlib>
#include <new>
using namespace std;

class Mnozina
{
	int pocet;
	int i,;
public:
	string *prvky;
	Mnozina();
	Mnozina(int);
	Mnozina operator+ (Mnozina Sjednoceni);
	Mnozina operator- (Mnozina Rozdil);
	Mnozina operator* (Mnozina Prunik);
	void vypis();
	
};

Mnozina::Mnozina(int pocet)
{
	i = pocet;
	prvky = new string[i];
	int poradi = 1;
	for(int n = 0; n < i; n++)
	{
		cout << "Prvek " << poradi << "/" << pocet << ": "; 
		cin >>prvky[n];
		poradi++;
	}
}

Jo mel jsem tam par chyb uz to funguje k tomu vypis ted zkusim teda to sjednoceni

#include <iostream>
#include <cstdlib>
#include <new>
using namespace std;

class Mnozina
{
	int pocet;
	int i;
public:
	string *prvky;
	Mnozina();
	Mnozina(int);
	Mnozina operator+ (Mnozina Sjednoceni);
	Mnozina operator- (Mnozina Rozdil);
	Mnozina operator* (Mnozina Prunik);
	void vypis();
	
};

Mnozina::Mnozina(int pocet)
{
	i = pocet;
	prvky = new string[i];
	int poradi = 1;
	for(int n = 0; n < i; n++)
	{
		cout << "Prvek " << poradi << "/" << pocet << ": "; 
		cin >>prvky[n];
		poradi++;
	}
}

Mnozina::Mnozina()
{

}

void Mnozina::vypis()
{
	for(int n = 0; n < i; n++)
	{
		cout << prvky[n] << " ";
	}
}

int main (int argc, char *argv[]) 
{
	if ( argc != 3) 
	{
		cout << "Program chce dva short parametry" << endl;
		return 1;
	}	
	cout << "Zadavejte prvky pro mnoziny a a b" << endl;
	Mnozina a(atoi(argv[1])); Mnozina b(atoi(argv[2]));
	Mnozina c, d, e, f;
	cout << "Prvky a: "; a.vypis() ; cout << endl;
	cout << "Prvky b: "; b.vypis() ; cout << endl;
	/*
	cout << "* Sjednoceni c=a+b : ";
	c=a+b; c.vypis(); cout << " -" << c.getVelikost() << endl;
	cout << "* Prunik d=a*b : ";
	d=a*b; d.vypis(); cout << " -" << d.getVelikost() << endl;
	cout << "* Rozdil e=a-b : ";
	e=a-b; e.vypis(); cout << " -" << e.getVelikost() << endl;
	cout << "* Rozdil f=b-a : ";
	f=b-a; f.vypis(); cout << " -" << f.getVelikost() << endl;
	*/
	return 0;
}

Tak tohle je konecna funkcni verze... Jestli mate pripominky nebo napady tak napiste...

#include <iostream>
#include <cstdlib> 

using namespace std;

#define MNOZINA_MAX 255                 // Nastaveni maximalniho poctu prvku
string oznaceni[2] = { "a", "b" };		// Nastaveni oznaceni mnoziny pri zadavani
int oznaceni_act = 0;					// Nastaveni hodnoty pro urcovani mnoziny pri zadavni

class Mnozina {
    private: 
        string prvky[MNOZINA_MAX];      // pole pro ulozeni prvku mnoziny
        int velikost;                   // promenna pro ulozeni velikosti mnoziny
        int velikost_act;               // promenna pro sledovani aktualniho poctu prvku v mnozine
        bool preddefinovano;            // promenna pro zjisteni zda byla zadana velikost mnoziny
	public:
        Mnozina(int velikost = 0 );         // Konstruktor objektu
        bool obsahuje(string prvek);        // Vyhledani prvku
        void vypis();                       // Vypsani mnoziny
        int getVelikost();                  // Ziskani aktualniho poctu prvku
        string getPrvek(int index);         // Ziskani prvku (podle indexu)
        bool addPrvek(string prvek);        // Prida prvek do mnoziny
        Mnozina operator+(Mnozina param);   // Operator sjednoceni
        Mnozina operator*(Mnozina param);   // Operator prunik
        Mnozina operator-(Mnozina param);   // Operator rozdil
};

Mnozina::Mnozina(int velikost) 
{
    this->velikost = 0;
    this->velikost_act = 0;
    this->preddefinovano = false;
    if(velikost > 0){
        if(velikost > MNOZINA_MAX){
            cout << "Velikost mnoziny je prilis velka." << endl;
            cout << "Velikost nastavena na " << MNOZINA_MAX << endl;
            this->velikost = MNOZINA_MAX;
        } else {
            this->velikost = velikost;
        }
        this->preddefinovano = true;
        for(int i = 0; i < this->velikost; i++){
            string input;
            cout << "Prvek " << i + 1 << "/" << oznaceni[oznaceni_act] << " ";
            cin >> input;
            this->addPrvek(input);
        }
        this->velikost = this->velikost_act;
		oznaceni_act++;
    }
}

bool Mnozina::obsahuje(string prvek)
{
    for(int i = 0; i < this->velikost; i++){
        if(this->prvky[i] == prvek)
            return true;
    }
    return false;
}

void Mnozina::vypis()
{
    for(int i = 0; i < this->velikost; i++){
        cout << this->prvky[i] << " ";
    }
}

int Mnozina::getVelikost()
{
    return this->velikost;
}

string Mnozina::getPrvek(int index)
{
    if(index < this->velikost)
        return this->prvky[index];
    else {
        cout << "Index mimo velikost mnoziny." << endl;
        return NULL;
    }
}

bool Mnozina::addPrvek(string prvek)
{
    if(this->preddefinovano && (this->velikost_act >= velikost))
	{
        cout << "Mnozina je plna." << endl;
        return false;
    } else if(this->velikost_act >= MNOZINA_MAX)
	{
        cout << "Mnozina ma maximalni velikost." << endl;
        return false;
    }
    if(this->obsahuje(prvek))
	{
        return true;
    }
    this->prvky[this->velikost_act++] = prvek;
    if(!this->preddefinovano)
        velikost++;
    return true;
}

Mnozina Mnozina::operator+(Mnozina param)
{
    Mnozina vysledek;
    for(int i = 0; i < this->velikost; i++)
        vysledek.addPrvek(this->prvky[i]);
    for(int i = 0; i < param.getVelikost(); i++){
        string tmp = param.getPrvek(i);
        if(!this->obsahuje(tmp)){
            if(!vysledek.addPrvek(tmp)){
                cout << "Mnoziny jsou prilis velke pro sjednoceni." << endl;
                return vysledek;
            }
        }
    }
    return vysledek;
}

Mnozina Mnozina::operator-(Mnozina param)
{
    Mnozina vysledek;
    for(int i = 0; i < this->velikost; i++){
        if(!param.obsahuje(this->prvky[i]))
            vysledek.addPrvek(this->prvky[i]);
    }
    return vysledek;
}

Mnozina Mnozina::operator*(Mnozina param){
    Mnozina vysledek;
    for(int i = 0; i < param.getVelikost(); i++){
        string tmp = param.getPrvek(i);
        if(this->obsahuje(tmp))
            vysledek.addPrvek(tmp);
    }
    return vysledek;
}

int main (int argc, char *argv[]) 
{
    if ( argc != 3) 
	{
        cout << "Program chce dva short parametry" << endl;
        return 1;
	}
    cout << "Zadavejte prvky pro mnoziny a a b" << endl;
    Mnozina a(atoi(argv[1])) ;
    Mnozina b(atoi(argv[2])) ;
    Mnozina c, d, e, f;
    cout << "Prvky a: ";
    a.vypis();
    cout << endl;
    cout << "Prvky b: ";
    b.vypis();
    cout << endl;
    cout << "* Sjednoceni c=a+b : ";
    c = a + b;
    c.vypis();
    cout << " -" << c.getVelikost() << endl;
    cout << "* Prunik d=a*b : ";
    d = a * b;
    d.vypis();
    cout << " -" << d.getVelikost() << endl;
    cout << "* Rozdil e=a-b : ";
    e = a - b;
    e.vypis();
    cout << " -" << e.getVelikost() << endl;
    cout << "* Rozdil f=b-a : ";
    f = b - a;
    f.vypis();
    cout << " -" << f.getVelikost() << endl;
    return 0;
}

Ak mozes pouzit stl tak si skus pozriet set. Mozes to potom velmi jednoducho zjednodusit.

Mohol by si pouzit referencie v parametroch:

        bool obsahuje(const string &prvek)const; 
        void vypis()const;       
        int getVelikost()const;                 
        const string &getPrvek(int index)const;   
        bool addPrvek(const string &prvek);        
        Mnozina operator+(const Mnozina &param)const;
        Mnozina operator-(const Mnozina &param)const;
        Mnozina operator*(const Mnozina &param)const;