• Najnowsze pytania
  • Bez odpowiedzi
  • Zadaj pytanie
  • Kategorie
  • Tagi
  • Zdobyte punkty
  • Ekipa ninja
  • IRC
  • FAQ
  • Regulamin
  • Książki warte uwagi

Pytanie o ocene programu

VPS Starter Arubacloud
0 głosów
596 wizyt
pytanie zadane 28 maja 2019 w C i C++ przez niezalogowany

Chciałem zadać pytanie czy ktoś jest zainteresowany podobnym tematem i chciałem załączyć program, ale nie udało się bo przekroczył 1500 znaków. Program "rysował" szafki kuchenne dolne w dużym uproszczeniu. "Rysował" tj wklejało się do linicommand tekst z pliku i wtedy rysował. Przez wklejenie bo tak szybciej i scr programie przestał działać, virus czy co. A, że to strasznie wypociny były(lispa tam nie uświadczysz ani żadnego ui), to teraz próbuję go napisać na nowo (na razie rozkroje do txt). I jak by ktoś miał chęć coś poklikać czy ocenić to chętnie udostępnię ten stary program. Nowy jak bym napisał to także nie w celach komercyjnych. Chciałem na githuba wrzucić, ale to jakaś męczarnia, a i lepiej się swoimi wypocinami lokalnie chwalić, niż globalnie a poza tym po polsku.

Tu załączę tylko maina

#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>
#include "szafka.hpp"
#include "punkt.hpp"
#include "komenda.hpp"
#include "Tekran_alfanumeryczny.h"
using namespace std;

class dane {

public:
int sz=700,gl=600,wys =820, dl=600,gr=18;

dane (int szsz, int wys);

};

void menu_1 ( string dana,int &a,string opis ="podaj nowa ");
void narysuj(int x=5, int y=1);


Tekran_alfanumeryczny ekran;
int sz=700,gl=600,wys =820, dl=600,gr=18, Y, X=0,suma=0;
string szafki;

//int Szafka::typ;
int main()
{
    system("taskkill /F /IM notepad.exe");

    fstream plik, pdwg;
    plik.open("1.txt",ios::out);
    plik.close();

    ekran.wyczysc();

    Punkt p;
    p={100,200,300};
    p.zmienZnak('<','<');
  //  p.wy(scr,2);
   // p.wy(scr,1);

  int opcja=1;

    while (opcja)
   {
       ekran.napisz(1,1,"[1] szerokosc: ="+to_string(sz)+"[mm]");
       ekran.napisz(1,2,"[2] wysokosc: ="+to_string(wys)+"[mm]");
       ekran.napisz(1,3,"[3] grubosc plyty: ="+to_string(gr)+"[mm]");
       ekran.napisz(1,4,"[4] glebokosc: ="+to_string(gl)+"[mm]");
       ekran.napisz(1,5,"[5] Dodaj szafke!");
       ekran.napisz(1,6,"polozenie uklau wspolzednych");

       ekran.napisz(1,7,"["+to_string(Szafka::ucsX)+",0,0]");

       narysuj();
       cout<<"Wcisnij [0] by zakonczyc menu \n";
       cout<<"podaj opcje menu [0-9]: "<<flush;

       cin>>opcja;

       if (!(cin.good())) {cin.clear(); cin.sync(); continue;}
       switch (opcja)
       {

            case 1: menu_1("szerokosc : ",sz);
            break;

            case 2:  menu_1("wysokosc : ",wys);
            break;

            case 3: menu_1("grubosc : ",gr);
            break;

            case 4: menu_1("glebokosc : ",gl);
            break;

            case 5: { Szafka *sz1=new Szafka(sz,wys,gl,gr);
                    sz1->wys(2);
                    string str1= "|          |";
                    string str2= " Typ "+to_string(Szafka::typ)+" ";
                    size_t poczatek=(str1.size()-str2.size())/2;
                    size_t dlugosc=str2.size();
                    str1.replace(poczatek,dlugosc,str2);
                    ekran.napisz(X+5,Y+2, str1);

                    str1= "|          |";
                    str2= " "+to_string(sz)+" ";
                    poczatek=(str1.size()-str2.size())/2;
                    str1.replace(poczatek,str2.size(),str2);
                    ekran.napisz(X+5,Y+3, str1);
                    X+=str1.size();
                    suma+=sz;
                    string suma1(25,'.');
                    ekran.napisz(0,Y+4, suma1);
                    suma1="suma = "+to_string(suma);
                    ekran.napisz(X/2,Y+4, suma1);
                    ekran.wyswietl();
                    delete sz1;}
            break;

            case 6:  Szafka::typ=0;
            break;

            case 7:  Szafka::typ=1;
            break;

            case 8:  Szafka::typ=2;
            break;

            case 9:  Szafka::typ=3;
            break;
       }

   }

    //system("1.txt");
    //system("D:\\c++\\kuchnia\\szafki\\2.dwg");
    //pdwg.open("1.dwg",ios::out|ios::app);
    //pdwg.close();

    return 0;
}

void menu_1 ( string dana,int &a,string opis){
     do {
        cout<<opis<<dana;
        cin>>a;
        cin.clear(); cin.sync();
       if(!(a)) {cout<<"    bledna liczba       "; continue;}
        } while(!(cin.good()));
}

void narysuj(int x, int y){

    int z=20;

    y=4; x=30;
    ekran.napisz(x,y-3, "         ___________ ___");
    ekran.napisz(x,y-2, "....... /          /|  |");
    ekran.napisz(x,y-1, "...... /          / |  |");
    ekran.napisz(x,y-0, "..... /__________/  |[2]wysokosc = "+to_string(wys));
    ekran.napisz(x,y+1, "......|         |   |  |..............................||..");
    ekran.napisz(x,y+2, "......|         |   | _|_.............................||..");
    ekran.napisz(x,y+3, "......|         |  /   /..............................||..");
    ekran.napisz(x,y+4, "......|         | /[4]glebokosc = "+to_string(gl)+"....[3]grubosc plyty ="+to_string(gr)+" ");
    ekran.napisz(x,y+5, "......|_________|/ __/");
    ekran.napisz(x,y+6, "......|         | ");
    ekran.napisz(x,y+7, "......|__     __|");
    ekran.napisz(x,y+7, " [1]szerokosc = "+to_string(sz)+" ");


    string str1= "|_________|";
    string str2= " "+to_string(sz)+" ";
    str1.replace(3,str2.size(),str2);
   y=13; x=4;
    ekran.napisz(x,y-0, "___________");
    ekran.napisz(x,y+1, "|         |");
    ekran.napisz(x,y+2, "|   bez   |");
    ekran.napisz(x,y+3, "|_________|");
    ekran.napisz(x,y+4, "| frontu  |");
    ekran.napisz(x,y+5, "|_________|");
    ekran.napisz(x,y+6, str1);
    ekran.napisz(x-2,y+7, " [6] Typ 0   ");

    x+=z;
    ekran.napisz(x,y,   "___________ ");
    ekran.napisz(x,y+1, "|        O|");
    ekran.napisz(x,y+2, "|         |");
    ekran.napisz(x,y+3, "|         |");
    ekran.napisz(x,y+4, "|         |");
    ekran.napisz(x,y+5, "|_________|");
    ekran.napisz(x,y+6, str1);
    ekran.napisz(x-2,y+7, " [7] Typ 1   ");

    x+=z;
    ekran.napisz(x,y,   "___________");
    ekran.napisz(x,y+1, "|   O|O   |");
    ekran.napisz(x,y+2, "|    |    |");
    ekran.napisz(x,y+3, "|    |    |");
    ekran.napisz(x,y+4, "|    |    |");
    ekran.napisz(x,y+5, "|____|____|");
    ekran.napisz(x,y+6, str1);
    ekran.napisz(x-2,y+7, " [8] Typ 2   ");

    x+=z;
    ekran.napisz(x,y,   "___________");
    ekran.napisz(x,y+1, "|____O____|");
    ekran.napisz(x,y+2, "|    O    |");
    ekran.napisz(x,y+3, "|_________|");
    ekran.napisz(x,y+4, "|    O    |");
    ekran.napisz(x,y+5, "|_________|");
    ekran.napisz(x,y+6, str1);
    ekran.napisz(x-2,y+7, " [9] Typ 3   ");


    ekran.napisz(30,y+9, "   Obecny Typ "+to_string(Szafka::typ)+"    ");

    Y=y+9;
   // ekran.napisz(x+4,y+1, nazwa);
  //  ekran.napisz(x+7,y+2, to_string(pokazuje));
  //  ekran.napisz(x+14,y+2, jednostki);
    ekran.wyswietl();
}

 

komentarz 28 maja 2019 przez Szahid Pasjonat (20,930 p.)
Protip. Na gitlabir repozytoria są domyślnie prywatne
komentarz 28 maja 2019 przez niezalogowany
Bardziej mi chodzi czy  ktoś w takim temacie się interesuje, w grupie coś mądrego łatwej wymyślić. To co chcę sam napiszę ale na pewno nie będzie to poprawny c++, no i pewnie znowu z pół roku przejdzie, a powinno zająć to zająć 2-3 dni.
komentarz 28 maja 2019 przez Szahid Pasjonat (20,930 p.)
Obawiam się że zbyt ogólnie napisałeś. W jakim temacie się interesuje? W temacie programowania, pisania w konsoli, szafek kuchennych. Nie rozumiem czego oczekujesz :)
komentarz 28 maja 2019 przez niezalogowany
a jeszcze mam klasę front niej wszystkie potrzebne wymiary, po której będą dziedziczyły klasy, front1, front2, i ale mam pozostałą część szafki, gdze nie interesuje mnie co jest w frontach1, 2 tylko grubość i frontu 1,2..., ale chce zrobić tylko jeden obiekt front a nie konkretny typ frontu. Jak to najlepiej zrobić przez jakąś funkcję wirtualną?
komentarz 28 maja 2019 przez DragonCoder Nałogowiec (36,500 p.)

1. chciałem załączyć program, ale nie udało się bo przekroczył 1500 znaków. 

jest problem, a jest nim> #include <windows.h>, bo jestem na linuxie i go nei odpale

2. 

 x+=z;
    ekran.napisz(x,y,   "___________ ");
    ekran.napisz(x,y+1, "|        O|");
    ekran.napisz(x,y+2, "|         |");
    ekran.napisz(x,y+3, "|         |");
    ekran.napisz(x,y+4, "|         |");
    ekran.napisz(x,y+5, "|_________|");
    ekran.napisz(x,y+6, str1);
    ekran.napisz(x-2,y+7, " [7] Typ 1   ");

nie da sie tu uzyc petli?

komentarz 28 maja 2019 przez niezalogowany
edycja 28 maja 2019

@Szahid, 

Najpierw stworzenia programu dla wykonawcy kuchni.  A później jakiś małych programików c++ do rysowania w autocadzie.

A na tą chwilę potrzebuję funkcji wirtualnej która wczyta typ frontu i poda jego grubość która:

class skrzyniadolna:Skrzynia {

    Skrzynia sk;
    Front grubosc // potezebuje funkcji która weźmie grubość frontu 1 lub frontu 2 .... lub 10

    int wysokoscOdPodlogi;
    int odlegloscOdsciany;
    Plyta boczeklewy, boczekprawy, spod, wzmocnienietyl, wzmocnienieprzod;

};

jak chcesz cały stary pogram to mogę na prv wysłać

komentarz 28 maja 2019 przez niezalogowany
edycja 28 maja 2019

@DragonCoder,

I tak nie odpalisz bo to tylko tylko jeden plik z pięciu, a windows.h jes tylko do zmykania notatnika, no i może do czyszczenia ekranu, ale to żaden problem można przewijać konsolę. Ale i tak jest cały do przeróbki, jak laik będzie używał to musi być ui w Qt.

A najlepiej jak by nowy program chulał pod androidem przynajmniej rozkroje. Czy to z Qt ciężko przenieść.

Pętla pętlą, ale musiałem widzieć co "rysuję" w oknie konsoli więc optymalizacja kodu tu nie miała znaczenia .

a komunikacja z zwcadem jest tu

#ifndef KOMENDA_HPP_INCLUDED
#define KOMENDA_HPP_INCLUDED
#include "punkt.hpp"
class Komenda
{

    Punkt m_A;
    Punkt m_B;
    Punkt wym;
    std::string m_nazwa;
    std::string m_warstwa;
    std::string m_polecenie;
public:
    Komenda (std::string warstwa="0", std::string polecenie="_box ", Punkt A={0,0,0}, Punkt B={1000,1000,1000} )
    {
        m_warstwa=warstwa; m_polecenie=polecenie; m_A=A; m_B=B;
    };

    void command (std::string polecenie="_box", std::string nazwa="front", char z=' ')
    {
         m_polecenie=polecenie+z+nazwa;
    }
     //void dP (fstream &p)

    int color(std::string warstwa) {
        int suma=0;
        for (char x:warstwa) suma+=(int)x;
        while (suma>250) {suma=suma/15;}
        return suma;
        }

      void nE (std::string warstwa="0",int ilepunktow=3)
        {
        warstwa=m_warstwa;
        if (warstwa!="0") std::cout<<"_.-layer _New "<<warstwa<<"\n"<<"_Set "<<warstwa<<"\n"<<"_color "<<color(warstwa)<<"\n\n"<<std::endl;
        std::cout<<m_polecenie<<std::endl;
        m_A.wy();
        m_B.wy(ilepunktow);
        }
      void dP (std::fstream &p,std::string warstwa="0",int ilepunktow=3)
    {
        warstwa=m_warstwa;
        if (warstwa!="0") p<<"_.-layer _New "<<warstwa<<"\n"<<"_Set "<<warstwa<<"\n"<<"_color "<<color(warstwa)<<"\n\n"<<std::endl;
        p<<m_polecenie<<std::endl;
        m_A.wy(p);
        m_B.wy(p,ilepunktow);
    }

        Punkt roznica()
            {
                wym.x=m_B.x-m_A.x;
                wym.y=m_B.y-m_A.y;
                wym.z=m_B.z-m_A.z;
                return wym;
            }
};


#endif // KOMENDA_HPP_INCLUDED

 

komentarz 29 maja 2019 przez j23 Mędrzec (194,920 p.)

Pętla pętlą, ale musiałem widzieć co "rysuję" w oknie konsoli

const char* box[] = {
	"___________",
	"|        O|",
	"|         |",
	"|         |",
	"|         |",
	"|_________|"
};

for(int i = 0; i < 6; ++i, ++y)
	ekran.napisz(x, y, box[i]);

Dalej widać, co rysujesz, a kodu jakby mniej :)

komentarz 29 maja 2019 przez niezalogowany

to fakt ładniej wygląda, ale

terminate called after throwing an instance of 'std::out_of_range'
  what():  basic_string::replace: __pos (which is 2914) > this->size() (which is 2781)
komentarz 29 maja 2019 przez j23 Mędrzec (194,920 p.)
To nie ma bezpośredniego związku z kodem, który podałem, bo on jest poprawny.
komentarz 29 maja 2019 przez niezalogowany

Akurat main był robiony z myślą, że to przerzucę do jakiś okienek i Tekran_alfanumeryczny.h i do tego nie przykładałem szczególnej wagi.

wrzucę pozostałe pliki dwa już są main.cpp i komenda.hpp

zostały może bana nie dostanę a ktoś zechce skompilować program Tekran_alfanumeryczny.h (to z opus magnum), szafka.cpp. szafka.hpp i punkt.hpp

programTekran_alfanumeryczny.h


#ifndef _Tekran_alfanumeryczny_h_
#define _Tekran_alfanumeryczny_h_

#include <string>
#include <iostream>


class Tekran_alfanumeryczny {

    std::string    tresc;
    char           znak_tla;
 public:
    enum {szerokosc_ekranu = 103, wysokosc_ekranu_jako = 27};
  //  static constexpr int wysokosc_ekranu=10;

    Tekran_alfanumeryczny (char znak ='.')
    {
        znak_tla=znak;
        wyczysc();
    }
    void wyczysc()
    {
        tresc.clear();
        std::string jedna_linijka (szerokosc_ekranu-1,znak_tla);
        jedna_linijka +='\n';
        for (int i=0; i<wysokosc_ekranu_jako;++i) tresc+=jedna_linijka;
    }
    void wyswietl (){

    std::cout<<tresc<<std::flush;
    }
    void napisz (int kolumna, int rzad, std ::string tekst) {

    tresc.replace((szerokosc_ekranu*rzad)+kolumna, tekst.length(), tekst);
    }
};


#endif // TEKRAN_ALFANUMERYCZNY_H_INCLUDED

szafka.cpp

#include <iostream>
#include <fstream>
#include "szafka.hpp"
#include "punkt.hpp"
#include "komenda.hpp"

using namespace std;

extern int Szafka::typ=1;
   void Szafka:: wys(short opcja)
   {
      // F.nE("front"); BL.nE("boczek_lewy"); BP.nE("boczek_prawy"); SPOD.nE("spod"); Pu.nE("polka");

    if (opcja==1)
       {for (int i=1;i<3;i++)F[i].nE();
       BL.nE(); BP.nE(); SPOD.nE(); Pu.nE(); listwy[0].nE();listwy[1].nE();
       plecy.nE();
       SC.nE();
       blat.nE();
       blatfazuj.nE("0",1);
       ucsX+=szerokosc;
       cout<<"\n----------------------------\n"<<szerokosc<<"\n----------------------------\n";
 // 1
       }
    else if (opcja==2){

       p.open("1.txt",ios::out|ios::app);

       if (typ==1)      for (int i=0;i<1;i++)F[i].dP(p);
       else if (typ==2) for (int i=1;i<3;i++)F[i].dP(p);
       else if (typ==3) for (int i=3;i<6;i++)F[i].dP(p);

        BL.dP(p); BP.dP(p); SPOD.dP(p); Pu.dP(p); listwy[0].dP(p);listwy[1].dP(p);
       plecy.dP(p);
       SC.dP(p);
       blat.dP(p);
       blatfazuj.dP(p,"0",1);
       p<<endl;
       cout<<"\n----------------------------\n"<<szerokosc<<"\n----------------------------\n";
       ucsX+=szerokosc;
        p<< "_.ucs "<<szerokosc<<",0,0 "<<(szerokosc+100)<<",0,0 "<<szerokosc<<",100,0 ";
       cout<<"\n*********************\n"<<ucsX<<"("<<ucsX+600<<")"<<"\n***************************\n";
       p.close();
       }

   }

    double Szafka::ucsX;

 Szafka::Szafka (int Kszerokosc=700, int Kwysokosc=820, int Kdlugosc=1000, int Kglebokosc=520, int Kgrubosc=18)
    {
        szerokosc=Kszerokosc;
        wysokosc=Kwysokosc;
        dlugosc=Kdlugosc;
        glebokosc=Kglebokosc;
        grubosc=Kgrubosc;

    }
Szafka::Szafka (int Kszerokosc, int Kwysokosc, int Kglebokosc, int Kgrubosc):
        szerokosc(Kszerokosc),
        wysokosc(Kwysokosc),
        glebokosc(Kglebokosc),
        grubosc(Kgrubosc)
    { }

szafka.hpp

#ifndef SZAFKA_HPP_INCLUDED
#define SZAFKA_HPP_INCLUDED
#include "komenda.hpp"

class Szafka
{
    public: Komenda A;
    private:
  
    int szerokosc=700;
    int dlugosc=600;
    int glebokosc=520;
    int wysokosc=820;
    int grubosc=18;



   std::fstream p;

    double x;
    double y;
    double z;
    double luz;

   ///Punkt poczatek {x,y,z};

public:
    static int typ;
    static double ucsX;
    Szafka (int szerokoscc):szerokosc(szerokoscc){
        //cin>>szerokosc;
        }
    Szafka (int Kszerokosc, int Kwysokosc, int Kdlugosc, int Kglebokosc, int Kgrubosc);
  
    Szafka (int Kszerokosc=700, int Kwysokosc=820, int Kglebokosc=520, int Kgrubosc=18);
    Szafka (void){} ;
    Szafka (std::fstream &p){} ;
   


/* 1 */  Komenda F [6] {  {"front","_box",{x+luz/2.0,y,z}, {x+szerokosc-luz/2.0,grubosc,wysokosc-5.0}},
/* 2 */                      {"front","_box",{x+luz/2.0,y,z}, {x+szerokosc/2-luz/2.0,grubosc,wysokosc-5.0}},
/* 3 */                      {"front","_box", {x+szerokosc/2+luz/2.0,y,z},{x+szerokosc-luz/2.0,grubosc,wysokosc-5.0}},
/* 4 */                            {"front","_box",{x+luz/2.0,y,z}, {x+szerokosc-luz/2.0,grubosc,2.0/5.0*(wysokosc-5.0-z)+z-luz/2.0}},
/* 5 */                            {"front","_box",{x+luz/2.0,y,2.0/5.0*(wysokosc-5.0-z)+z+luz/2.0}, {x+szerokosc-luz/2.0,grubosc,4.0/5.0*(wysokosc-5.0-z)+z-luz/2.0}},
/* 6 */                            {"front","_box",{x+luz/2.0,y,4.0/5.0*(wysokosc-5.0-z)+z+luz/2.0}, {x+szerokosc-luz/2.0,grubosc,wysokosc-5.0}},
                  };
/* 7 */    Komenda BL   {"boczek lewy","_box",{x,y+grubosc,z+grubosc}, {x+grubosc,glebokosc-80,wysokosc}};
/* 8 */    Komenda BP   {"boczek prawy","_box",{szerokosc+x,y+grubosc,z+grubosc}, {x+szerokosc-grubosc,glebokosc-80,wysokosc}};
/* 9 */    Komenda SPOD {"spod","_box",{x,y+grubosc,z}, {x+szerokosc,glebokosc-80,z+grubosc}};
/* 10*/    Komenda Pu {"polka posrednia","_box",{x+grubosc,y+grubosc,wysokosc/2.0-grubosc/2.0}, {x+szerokosc-grubosc,glebokosc-80,wysokosc/2.0+grubosc/2.0}};
/* 11*/    Komenda listwy[2] {{"listwy","_box",{x+grubosc,y+grubosc,wysokosc-grubosc}, {x+szerokosc-grubosc,y+grubosc+100,wysokosc}},
/* 12*/                        {"listwy","_box",{x+grubosc,glebokosc-80-100,wysokosc-grubosc}, {x+szerokosc-grubosc,glebokosc-80,wysokosc}}};
/* 13*/    Komenda plecy {"plecy","_box",{x+luz/2.0,y+glebokosc-80,z+1}, {x+szerokosc-luz/2.0,y+glebokosc-80+3,wysokosc-1}};
/* 14*/    Komenda SC {"sciana","_box",{x,y+glebokosc,z}, {x+szerokosc,grubosc+glebokosc,2500}};
/* 15*/    Komenda blat {"blat","_box",{x,y,wysokosc}, {x+szerokosc,glebokosc,wysokosc+38}};
/* 16*/    Komenda blatfazuj {"0","_FILLET", {x+szerokosc/2,y,wysokosc+38},{5}};

   void wys(short opcja);


};


#endif // SZAFKA_HPP_INCLUDED

punkt.hpp

#ifndef PUNKT_HPP_INCLUDED
#define PUNKT_HPP_INCLUDED


class Punkt
{
public:
    double x;
    double y;
    double z;
private:
    char znak1 = ',';
    char znak2 = ',';
public:
    Punkt (double xx=0, double yy=0, double zz=0 )
    {
        x=xx; y=yy; z=zz;
    }

    void zmienZnak (char zz1, char zz2)
    {
        znak1=zz1; znak2=zz2;
    }
    void setx (int xx) {x=xx;}
  /// void wy()
///    {
///        cout<<x<<znak1<<y<<znak2<<z<<endl;
///    }
     void wy(std::fstream &p,short a=3)
    {
        if (a==3) p<<x<<znak1<<y<<znak2<<z<<std::endl;
        else if (a==2) p<<x<<znak1<<y<<std::endl;
        else if (a==1) p<<x<<std::endl;
    }
    void wy (short a=3)
    {
        if (a==3) std::cout<<x<<znak1<<y<<znak2<<z<<std::endl;
        else if (a==2) std::cout<<x<<znak1<<y<<std::endl;
        else if (a==1) std::cout<<x<<std::endl;
    }
    ~Punkt() {///cout<<"destruktor Punkt"<<endl;
    }
};



#endif // PUNKT_HPP_INCLUDED

 

komentarz 29 maja 2019 przez j23 Mędrzec (194,920 p.)

Poprawiłem nieco metodę napisz:

void napisz(int x, int y, const std::string &line) 
{
	int line_with = line.size();
	int line_offset = 0;

	if (y < 0 || y >= wysokosc_ekranu_jako || x >= szerokosc_ekranu) return;

	if (x < 0) {
		line_with += x;
		line_offset = -x;
		x = 0;
		if(line_with < 0) return;
	}
	else if (x + line_with > szerokosc_ekranu - 1) {
		line_with = szerokosc_ekranu - 1 - x;
	}

	auto it = line.begin() + line_offset;
	std::copy(it, it + line_with, tresc.begin() + (szerokosc_ekranu * y + x));
}

Przycina zawartość linii, jeśli wychodzi poza zakres "ekranu".

komentarz 29 maja 2019 przez niezalogowany

mam taki błąd kompilatora czy koś na szybko może mi to wytłumaczyć

main.cpp|70|error: invalid use of member (did you forget the '&' ?)|

gdzie mam tą referencję wpisać

#include <iostream>

using namespace std;
struct Punkt{
int x=0;
int y=0;
int z=0;
};

struct Plyta {

    int wysokosc;
    int szerokosc;
    int grubosc=18;
     Punkt Start;
};
class Skrzynia {
  protected:
    int wysokosc;
    int szerokosc;
    int glebokosc;
public:    Skrzynia (int s=700, int g=600,int w=820){
    wysokosc=w;
    szerokosc=s;
    glebokosc=g;
    }
};

class Front :public Skrzynia {
    Plyta pl;
    Skrzynia s;
    double prerwapionowa;
    double przerwapozoma;
    double marginesprawy;
    double margineslewy;
    double marginesgorna;
    double marginesdolny;
    char typ;
    Front (Skrzynia s, double marginesgorna=5, double marginesdolny=0, double margineslewy=1, double marginesprawy=1, char typ='L', double przerwapionowa=3, double przerwapozioma=3 ) {
        if (typ=='P')
            swap(marginesprawy,margineslewy);
        this->marginesgorna=marginesgorna;
        this->marginesdolny=marginesdolny;
        this->marginesprawy=marginesprawy;
        this->margineslewy=margineslewy;
        this->typ=typ;
        this->prerwapionowa=przerwapionowa;
        this->przerwapozoma=przerwapionowa;
        this->s=s;
    }



};
class frontpojedyczy:public Front {

    Front pojedyczty;
};
class frontpodwojnyFront {
    Front pojedyczty;
};

class skrzyniadolna: public Skrzynia {

    //grubosc  // potezebuje funkcji która wezmie grubosc frontu 1 lub frontu 2 .... lub 10

    int wysokoscOdPodlogi;
    int odlegloscOdsciany;
    int szerokoscwzmocnienie;
    Plyta boczeklewy {glebokosc-odlegloscOdsciany-grubosc, wysokosc-wysokoscOdPodlogi,grubosc,Plyta::Start};

        Plyta boczekprawy(){
            return {glebokosc-odlegloscOdsciany-grubosc,wysokosc-wysokoscOdPodlogi,grubosc,Plyta::Start);
        };
        Plyta  spod(){
            return {szerokosc,glebokosc-odlegloscOdscianygrubosc,Plyta::Start)}
        };
        Plyta  wzmocnienietyl(){
            return {szerokosc -2*grubosc,szerokoscwzmocnienie,grubosc,Plyta::Start};
       };
        Plyta wzmocnienieprzod()
            return {szerokosc -2*grubosc,szerokoscwzmocnienie,grubosc,Plyta::Start};
        };

        int grubosc () {
            ;
        }

};
int main() {
    cout << "Hello world!" << endl;
    return 0;
}

 

komentarz 30 maja 2019 przez j23 Mędrzec (194,920 p.)
Plyta boczeklewy() const {
    return { glebokosc - odlegloscOdsciany - grubosc, 
            wysokosc - wysokoscOdPodlogi,
            grubosc,
            {0, 0, 0}};
}
 

Analogicznie robisz z resztą metod.

komentarz 30 maja 2019 przez niezalogowany
edycja 30 maja 2019
wielkie dzięki, ale coś jeszcze nie działa muszę przegryźć temat i jeszcze raz przerobić dziedziczenie i polimorfizm.

a błąd kompilatora to

main.cpp|63|error: could not convert '{((((int)((const Skrzyniadolna*)this)->Skrzyniadolna::<anonymous>.Skrzynia::glebokosc) - ((int)((const Skrzyniadolna*)this)->Skrzyniadolna::odlegloscOdsciany)) - ((int)((const Skrzyniadolna*)this)->Skrzyniadolna::grubosc)), (((int)((const Skrzyniadolna*)this)->Skrzyniadolna::<anonymous>.Skrzynia::wysokosc) - ((int)((const Skrzyniadolna*)this)->Skrzyniadolna::wysokoscOdPodlogi)), ((const Skrzyniadolna*)this)->Skrzyniadolna::grubosc, {0, 0, 0}}' from '<brace-enclosed initializer lis|
komentarz 30 maja 2019 przez j23 Mędrzec (194,920 p.)

W tym kodzie jest kompletny śmietnik. Nawiasy nie do pary, funkcje traktowane jak zmienne - to nie mogło się skompilować. Nie wiem, jak Ty to pisałeś.

Plyta boczeklewy() const
{
    return { glebokosc - odlegloscOdsciany - grubosc(), wysokosc - wysokoscOdPodlogi, grubosc(), {} };
}

Plyta boczekprawy() const
{
    return { glebokosc - odlegloscOdsciany - grubosc(), wysokosc - wysokoscOdPodlogi, grubosc(), {} };
}

Plyta spod() const
{
    return { szerokosc, glebokosc - odlegloscOdsciany, grubosc(), {} };
}

Plyta wzmocnienietyl() const
{
    return { szerokosc - 2 * grubosc(), szerokoscwzmocnienie, grubosc(), {} };
}

Plyta wzmocnienieprzod() const
{
    return { szerokosc - 2 * grubosc(), szerokoscwzmocnienie, grubosc(), {} };
}

int grubosc() const
{
    return 0 /* ??? */;
}

 

komentarz 30 maja 2019 przez niezalogowany
edycja 30 maja 2019
"śmietnik" posprzątałem już wcześniejszej" mimo wszystko i tak się nie kompiluje, Nie wiem w czym jest problem bo jak utworzę obiekt płyta w kasie to wszystko jest ok.

funkcja grubość była problemem i brak konstruktorów w strukturze Plyta i Punkt
komentarz 31 maja 2019 przez niezalogowany

Jak przechwycić parametr domyślny

konstruktor plyta

struct Plyta {

    int wysokosc;
    int szerokosc;
    int grubosc;
  Punkt Start;
  Plyta (int w=20,int s=30,Punkt p={0,0,0},int g=18){
  wysokosc=w;
  szerokosc=s;
  grubosc=g;
  Start=p;
  }
  //int gruboscP() {return grubos};
};

obiekt plyta

Plytaboczeklewy { glebokosc - odlegloscOdsciany /*- grubosc odziedziczony po sobie paramet domyslny. Jak to zrobic?*/,
                            wysokosc - wysokoscOdPodlogi,
                            {}
                            /*,grubosc tu ok bo parametr domyslny*/
                            }; 

 

komentarz 31 maja 2019 przez niezalogowany
edycja 31 maja 2019

i jeszcze jedno pytanie czy da się zrobić licznik obiektów zależności od wartości pola a nie wszystkich obiektow

struct Plyta {

    int wysokosc=700;
    int szerokosc=780;
    int grubosc=18;
    string nazwa;
    static int licznik[5]; // czy jest mozliwosc zliczania obiektow wzaleznosci od grubosci i nazwy\
                                // tj licznik obiektow plyta o grubosci 18mm , icznik obiektow o grubosci 3mm ,
                                 // tj licznik obiektow plyta o nazwa "czerwony", nazwa "niebieski";
  Punkt Start;
  Plyta (int w=20,int s=30,Punkt p={0,0,0},int g=18){
  wysokosc=w;
  szerokosc=s;
  grubosc=g;
  Start=p;
  }
  //int gruboscP() {return grubos};
};

i jeszcze coś w takim stylu

 // jezeli nie na danego koloru i grubosci 
  vector <plyta> a = new vector <plyta> ;
  //else if(a.name="jhgkj")  a.push_back();

lub coś takiego

class plytatyp {
int grubosc;
string nazwa;
static int licznik;
};

map<plytatyp,vector<plyta>> zestawienie;

 

komentarz 31 maja 2019 przez j23 Mędrzec (194,920 p.)
edycja 31 maja 2019 przez j23

Jak przechwycić parametr domyślny

Jedyne co możesz teraz zrobić, to stworzyć tymczasowy obiekt klasy Plyta i pobrać od niego grubość. Szczerze mówiąc nie podoba mi się takie rozwiązanie. Tak jest lepiej:

struct Plyta {
	int wysokosc;
	int szerokosc;
	int grubosc;
	Punkt Start;

    static const int DomyslnaGrubosc = 18;

	Plyta(int w = 20, int s = 30, Punkt p = {}, int g = DomyslnaGrubosc)
		:wysokosc(w), szerokosc(s), grubosc(g), Start(p)
	{}
};

/* ... */
Plytaboczeklewy { glebokosc - odlegloscOdsciany - Plyta::DomyslnaGrubosc, wysokosc - wysokoscOdPodlogi, {}, Plyta::DomyslnaGrubosc };

ale nie jestem pewien, czy to rozwiązuje problem. IMO klasa Skrzynia powinna posiadać pole gruboscPlyty, bo przecież płyty są różne, a użycie wartości domyślnej ogranicza konstrukcję skrzyni tylko do jednego typu płyty.

 

czy da się zrobić licznik obiektów zależności od wartości pola a nie wszystkich obiektow

Jeśli trzymasz wszystkie płyty w vectorze lub innym kontenerze, to jaki problem policzyć je z uwzględnieniem ich cech?

komentarz 31 maja 2019 przez niezalogowany
edycja 31 maja 2019
Dzięki za odpowiedzi na moje pytania. Trochę  są one chaotyczne, bo projekt jest na razie w fazie koncepcji, a złe zaplanowany stanie się bezużyteczny. Z dotychczasowych doświadczeń, wynika jak coś jest fajne zrobione, to chętnie się do tego wraca, a jak się przekombinuje to później nie da się tego rozwinąć. Tak jak z tym projektem który tu wkleiłem.

static const - obiecuje ze nie będę DomyslnaGrubosc  dla klasy tak?

Raczej jest postanowione że pojawi się klasa typPlyty bo generalnie są 2-3 typy do jednego projektu i do nich trzeba się odwołać do zamówienia i do entmaka;

ale muszę generalnie coś ala baze danych id każdej płyty, typ plyty, do jakiej szafki nalezy, i jakie ma fronty. Do tych wszystkich pól muszę mieć dostęp komendą entmake.

Jak ktoś miał jakieś pomysły, to ja chętnie się doszkolę. Dobrze by było by się dało to łatwo przeskalować na więźbę dachową np, bo tam też by były id , typ elementu(typ płyty), element kszałt(plyta), do  jakiej części dachu należy(szafka) no i klasa obsługująca komendy autocada, ale lispowe nie scryptowe szczególnie ta klasa musi być skalowalna.

i to muszę zmieścić w programowaniu po 2-3h dziennie.

Więc jakieś sugestie materiały mile wdzianie (podstawy lispa materiały ogarnięte), ale klasa c++ do tworzenia obiektów w autokadzie nie bardzo, tj jej porostu nie rozumiem! No i jakiś przykład do tworzenia dxf. Się trochę bawiłem w strukturę dxf, ale muszę mieć już utworzony dxf by go pozmieniać, a czystego nie umiem stworzyć.

i jeszcze jedno bardzo ważnie pytanie jak zrobić by stworzyć klasę

typpłyty * typ1 = new typpłyty //tylko jeżeli niema typu1, a jak jest to podpiąć pod te pole ala "bazy danych" . Ja to widzę jako lista typ1 i lista tych list typów
komentarz 31 maja 2019 przez j23 Mędrzec (194,920 p.)

static const - obiecuje ze nie będę DomyslnaGrubosc  dla klasy tak?

Co?

typpłyty * typ1 = new typpłyty //tylko jeżeli niema typu1, a jak jest to podpiąć pod te pole ala "bazy danych" .

Sformułuj inaczej pytanie, bo za cholerę nie wiem, o co Ci chodzi.

komentarz 31 maja 2019 przez niezalogowany
edycja 1 czerwca 2019

Co?

no tak na logikę wziąłem

static - wspólny adres dla wszystkich klas;

const - stała wartość dla obiektu;

static const = wspólny adres ze stałą wartością

Sformułuj inaczej pytanie, bo za cholerę nie wiem, o co Ci chodzi.

w sumie o to

http://www.algorytm.org/klasyczne/lista/lista-1-c.html

if (pomoc != NULL && (pomoc->nazwisko).compare(nowa->nazwisko) == 0) // wizytówka z podanym nazwiskiem już istnieje

a i wiem dlaczego struktury a przez to funkcje, które poprawiłeś nie chciały działać bez konstruktorów, (bo miały wartości domyślne, a jak są to mi kompilator nie chce skompilować)

komentarz 1 czerwca 2019 przez niezalogowany
przepraszam za te poprzednie głupoty o listach co wypisywałem idiota to idiota zapomniałem o STL. Chodziło mi o https://stackoverflow.com/questions/7531981/how-to-instantiate-a-static-vector-of-object
komentarz 1 czerwca 2019 przez j23 Mędrzec (194,920 p.)
No można tak zrobić, ale to rozwiązanie jest takie sobie.
komentarz 1 czerwca 2019 przez niezalogowany
edycja 1 lipca 2019

właśnie patrzę że coś nie działa?

#include <iostream>
#include <vector>
#define fo(x) cout<<(#x)<<"="<<(x)<<endl;
#define co(x) cout<<(x)<<endl;
#define ci(x) cin>>(x);

using namespace std;

struct a {
    std::string name;
    int grubosc;
  //  a *wsk =nullptr;
    a* obj=new a;
  public:
      static vector<a> a_typ;
      a(string  n="",int g=0):name(n),grubosc(g){

     a_typ.push_back(obj);    // tu jeszcze find_if
      }
    void   wy ()
    {
        fo(name);
        fo(grubosc);
    }
    void we ()
    {
        ci(name);
        ci(grubosc);
    }
};
vector<a> a:: a_typ;

int main() {
    cout << "Hello world!" << endl;
    a aa[]={{"a",1},{"b",2},{"c",3},{"a",1},{"e",5}};
    for (auto x:aa ) x.wy();
    cout<<aa[0].a_typ.size();
    return 0;
}

 

komentarz 1 czerwca 2019 przez j23 Mędrzec (194,920 p.)
edycja 1 czerwca 2019 przez j23

Nie działa, bo masz niekończącą się rekurencję - podczas tworzenia nowej instancji struktury a tworzona jest kolejna nowa instancja (pole obj), a ta tworzy nową... i tak bez końca (tzn. do przepełnienia stosu).

 

Jeśli już, to tak:

struct a {
    std::string name;
    int grubosc;

public:
    static vector<a*> a_typ;
    
    a(string n = "", int g = 0) 
        :name(std::move(n)), grubosc(g)
    {
        a_typ.push_back(this);
    }
    
    ~a()
    {
        a_typ.erase(find(a_typ.begin(), a_typ.end(), this));
    }

    ...
};

 

PS. nie wklejaj kodu jako plain-text.

komentarz 1 czerwca 2019 przez niezalogowany

A przez przesunięcie da się to obejść?

https://en.cppreference.com/w/cpp/container/list/emplace_back

 President(President&& other)
        : name(std::move(other.name)), country(std::move(other.country)), year(other.year)
    {
        std::cout << "I am being moved.\n";
    }
    President& operator=(const President& other) = default;

 

komentarz 1 czerwca 2019 przez j23 Mędrzec (194,920 p.)
Nie, podałem poprawny przykład.
komentarz 1 czerwca 2019 przez niezalogowany

@j23,
super dzięki!!!

komentarz 1 czerwca 2019 przez niezalogowany
edycja 1 czerwca 2019

@j23,

tylko mi destruktor nie działa, ale i tak nie chcę go mieć w tym miejscu tylko main bo zniszczę jeden obiekt i zniszczy mi cały wektor. Czy nie?

Ale z drugiej strony po co go niszczyć?

Ale naprawdę wielkie dzięki!!!

komentarz 1 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Że co? Destruktor w main?! I co to znaczy, że destruktor Ci nie działa? On musi działać. Chyba że coś namotałeś...

komentarz 1 czerwca 2019 przez niezalogowany
nie destruktor źle się wyraziłem chodziło mi o delete ale to i tak nie ma sensu;
komentarz 1 czerwca 2019 przez niezalogowany

no już mi pomysłów brakuje

 std::vector<a*>::iterator it;
         it=std::find_if(a_typ.begin(), a_typ.end(), (it==this)));

gwiazdkę wstawiałem wszędzie i tak próbowałem

myclass& ReturnReferenceToCurrentObject()       { return *this; }

komentarz 2 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Dlaczego użyłeś std::find_if, skoro wystarczy std::find (co też pokazałem we wcześniejszym przykładzie)?

komentarz 2 czerwca 2019 przez niezalogowany
edycja 2 czerwca 2019
bo się nie kompilował lub program się wywalał
komentarz 2 czerwca 2019 przez j23 Mędrzec (194,920 p.)
Nie kompilował się bo? Wywalał się w jakich okolicznościach?
komentarz 2 czerwca 2019 przez niezalogowany
edycja 2 czerwca 2019

Process returned -1073741819 (0xC0000005)   execution time : 5.071 s
Press any key to continue.

ale że zewnętrzna funkcja nie działa to już całkiem złupiałem

void dodaj_a (vector<a> &v) {
    a* obj=new a;
    obj->we();
    for (int i=0; i<v.size(); i++) {
        if ((obj->name)!=v[i].name && ((obj->grubosc)!=v[i].grubosc))  v.push_back(*obj);
    }
    delete obj;
};

int main() {
    vector<a> v1;
    for (int i =0; i<5; i++)
        dodaj_a(v1);
    for (int i =0; i<5; i++)
        v1[i].wy();
    return 0;
}

ani nie działa porównanie w konstruktorze przecież to są znane typy i nie trzba przeciążać operatora string i int

  for (int i=0; i<a_typ.size(); i++) {
      if ((this->name)!=a_typ[i].name && ((this->grubosc)!=a_typ[i].grubosc))  a_typ.push_back(this);

a i zakumałem o co chodzi z tym erase, ale to trochę koncepcja błędna w konstruktorze bo jak będę tworzył typ a to w klasie i ta klasa będzie miała żywot przez cały main. A wektor będzie tak jakby wektorem nazw elementów

fo((this->name)=="a"&&(this->grubosc)==1);

to działa poprawnie przed chwilą sprawdziłem

to coś ze stringiem jest nie halo bo po intach iterator działa normalnie.

-----------

to działa

main(){
  vector<n2> data= {{"a",1},{"b",2},{"c",3},{"a",1},{"e",5}};
   for (vector<n2>::iterator t=data.begin(); t!=data.end(); ++t) {
          if((*t).name=="a"&&(*t).li==1) cout<<"super";
}

a to w konstruktorze niekoniecznie niby logiczne, bo jak czegoś niema to nie można się do tego odwołać tak było ze wskaźnikami że trzeba było dodać element startowy by zaczęły działać

     fo((this->name)=="a"&&(this->grubosc)==1);
          for (vector<*a>::iterator this->a_typ.begin(); this->a_typ.end(); ++t) {
          if((*t).name=="a"&&(*t).li==1) cout<<"super";
    }

chyba polegnę i zrobię globalne kontenery i będzie git, bo się tylko czas traci powielając te same błędy

komentarz 2 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Czekaj, nie tak jakoś:

void dodaj_a (vector<a> &v) 
{
    a obj;

    obj.we();

	for (auto &o : v)
		if (obj.name == o.name && obj.grubosc == o.grubosc) return;

	v.push_back(std::move(obj));
}

 

komentarz 2 czerwca 2019 przez niezalogowany
super działa pięknie, i znowu dzięki

std::move(obj) - a w szoke mówili że trzeba się uczyć :)

Ale zmieniłem #define ci(x) cin>>(x) #define ci(x) {cout<<#x;cin>>(x);}, bo znowu myślałem że coś rypnięte, ale na szczęście krótki restart pomógł;

jeszcze raz dzięki, bo to nie dawało mi spokoju.
komentarz 3 czerwca 2019 przez niezalogowany

się udało w konstruktorze bo mi nie dawało to spokoju

    a(string n = "", int g = 0)
        :name(std::move(n)), grubosc(g) {
        bool prawda=1;
        for(it=this->a_typ.begin(); it!= this->a_typ.end(); it++)
            for(auto x :this->a_typ) {
                if (this->name==x->name&&this->grubosc==x->grubosc)
                    prawda=0;
            }
        if(prawda)
            a_typ.push_back(this);
    }

ale mimo to funkcja to dużo fajniejsze rozwiązanie

komentarz 4 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Co to jest? Po co ta pierwsza pętla for? Po co w ogóle te pętle? Skoro dodajesz wskaźnik this, to nie ma bata, żeby w a_typ już był ten sam wskaźnik, bo każdy obiekt ma swój własny unikalny adres (no chyba że nie usuwasz wskaźników z vectora w destruktorze, ale wtedy to błąd). Pokazałem Ci, jak to powinno poprawnie wyglądać, i nie wiem, po co jeszcze kombinujesz jak koń pod górę.

komentarz 4 czerwca 2019 przez niezalogowany

1) a wczoraj tak mnie wyszukać obiekt i jeżeli taki jest to przestawić na niego wskaźnik this i nadpisać. No cóż trochę nie wyszło.

2)tak naprawdę nie możliwości utworzenia obiektu jak przez funkcje by wszystko działało poprawnie czyli musi być funkcja przeładowana dla wskaźników.

3) próbowałem zaprzyjaźnić funkcję z klasą swoją klasą, ale chyba się nie da. I trzeba ją zaprzyjaźnić z pozostałymi klasami, ale pewnie nie da i takich efektów jak funkcja globalna.

http://www.obliczeniowo.com.pl/855 napisali:

"który jest opłacalny w zastosowaniu, gdy liczebność zbioru jest mała a liczebność sortowanych danych bazujących na elementach zbioru jest duża."

to jak opis mojej klasy

ale nie działa:

#include <iostream>
#include <set>
#include <algorithm>
#define fo(x) cout<<(#x)<<"="<<(x)<<endl;
#define co(x) cout<<(x)<<endl;
#define ci(x) cin>>(x);
#define fo2(x,y) cout<<(#x)<<"="<<(x)<<"\t"<<(#y)<<"="<<(y)<<endl;

using namespace std;

struct a {
    std::string name;
    int grubosc;

   static  std::set<a*>a_typ;

    a(string n = "", int g = 0)
        :name(std::move(n)), grubosc(g)
    {
             a_typ.insert(this);
    }

    ~a(){}

        void   wy ()
    {
        fo(name)
        fo(grubosc)
    }
};
set<a*> a:: a_typ;


int main() {
    cout << "Hello world!" << endl;
    a aa[]={{"a",1},{"b",2},{"c",3},{"a",1},{"e",5}};
  for (auto &x:aa ) x.wy();
  co("---------------------------------------")
  for(auto &x:aa[0].a_typ)x->wy();

    return 0;
}

tj działa ale elementy są nie posortowanie i podwójne?

komentarz 4 czerwca 2019 przez niezalogowany

ok znowu przeciążenie operatora się kłania to już działa jak powinno

#include <iostream>
#include <set>
#include <string>
#include <algorithm>
#define fo(x) cout<<(#x)<<"="<<(x)<<endl;
#define co(x) cout<<(x)<<endl;
#define ci(x) cin>>(x);
#define fo2(x,y) cout<<(#x)<<"="<<(x)<<"\t"<<(#y)<<"="<<(y)<<endl;

using namespace std;

struct a {
    std::string name;
    int grubosc;

   static  std::set<string>a_typ;

    a(string n = "", int g = 0)
        :name(std::move(n)), grubosc(g)
    {
             string temp = this->name+"_"+to_string(g);
             a_typ.insert(std::move(temp));
    }

    ~a(){}

        void   wy ()
    {
        fo(name)
        fo(grubosc)
    }
};
set<string> a:: a_typ;


int main() {
    cout << "Hello world!" << endl;
    a aa[]={{"a",1},{"b",2},{"c",3},{"a",1},{"e",5}};

  for (auto &x:aa ) x.wy();
  co("---------------------------------------")
for(auto &x:aa[0].a_typ) fo(x)
    return 0;
}

 

komentarz 4 czerwca 2019 przez j23 Mędrzec (194,920 p.)

@fisker,   strasznie niegramatycznie piszesz. Staraj się pisać poprawnie, bo czasami ni cholery nie można zrozumieć, o co Ci chodzi.

1) a wczoraj tak mnie wyszukać obiekt i jeżeli taki jest to przestawić na niego wskaźnik this i nadpisać. No cóż trochę nie wyszło.

Przecież a_typ trzyma wskaźniki. Skoro jest już w nim wskaźnik, którego szukasz, to nie musisz go nadpisywać. Dlatego pytałem o te pętle, które są kompletnie bez sensu (szczególnie ta pierwsza).

 

tj działa ale elementy są nie posortowanie i podwójne?

Elementy są posortowane, ale std::set trzyma wskaźniki, więc to wskaźniki są posortowane a nie obiekty klasy a. Trzeba zdefiniować predykat dla wskaźników:

struct a {
    std::string name;
    int grubosc;

    struct pred {
        bool operator()(const a* p1, const a* p2) const
        { 
            if(p1->name < p2->name) return true;
            if(p1->name > p2->name) return false;
            return p1->grubosc < p2->grubosc;
        }
    };

    static std::set<a*, pred> a_typ;

    a(std::string n = "", int g = 0)
        : name(std::move(n)), grubosc(g)
    {
        a_typ.insert(this);
    }

    ~a() 
    {
        a_typ.erase(this);
    }

    void wy() const
    {
        fo(name)
        fo(grubosc)
    }
};

std::set<a*, a::pred> a::a_typ;

 

komentarz 4 czerwca 2019 przez niezalogowany
i znowu dzięki chyba na jakieś Whiskey, będę ci musiał wysłać.

Jeszcze takie jedno pytanie do komunikacji z oknem QT, najlepiej stworzyć konstruktory których argumentem będzie string? A w konstruktorze dane sobie poprzypisywać?
komentarz 4 czerwca 2019 przez niezalogowany
edycja 4 czerwca 2019

chciałbym mieć szablon klas widziałem poruszanie się po polach klasy, ale nie wiem gdzie może ktoś wie tego szukać. Po co?

bo chlałbym mieć jedno fo(auto x), zamiast fo2(x,y), fo3(x,y,z)

coś w tym stylu (wstępna koncepcja funkcji);

#define
fo(*x) 
{
for (int i=(int)*x;i<(int)*x+sizeof(x);)  //coś w tym stylu
{
void* z=i;
cout<<*z;
i+=sizeof(*z);
}

 

komentarz 4 czerwca 2019 przez j23 Mędrzec (194,920 p.)
template<typename T>
void print(const T &arg)
{
    std::cout << arg << '\n';
}


template<typename T, typename ... Args>
void print(const T &arg, const Args& ... args)
{
    std::cout << arg << '\n';
    print(args...);
}

O to chodzi?

komentarz 4 czerwca 2019 przez niezalogowany
Super dokładnie oto; Gdzie Whiskey wysłać?
komentarz 5 czerwca 2019 przez niezalogowany

I znowu pytanie

1) Jak wczytuje string cin>> to ignoruje mi spacje; noskipws nie pomaga;

2) To samo jest z istringstream a aa("biala 18")daje mi grubosc =0;

        a(std::string dane="" )
    {
            std::istringstream ssdane(dane);
            ssdane >> this->name>> this->grubosc ;
            std::string temp = this->name+" "+std::to_string(this->grubosc)
             a_typ.insert(std::move(temp));
    }

internet też na ten temat niewiele mówi a to akurat jest kluczowa sprawa;

Właście ta i jeszcze jedna klasa jest ważna reszta to rzemiosło, dlatego to tak katuję.

komentarz 5 czerwca 2019 przez j23 Mędrzec (194,920 p.)
Kod, który podałeś, powinien działać. Błąd pewnie jest w innym miejscu.
komentarz 5 czerwca 2019 przez niezalogowany
Wczoraj się głowiłem skąd mam zerową grubość i wysyłałem na ekran zaraz po wyczytaniu.  Więc reszta programu nie ma nic do tego. Bardziej podejrzewam kompilator c::b, że domyślnie mi jakieś swoje modrości dołożył. Bo jak czytałem w komentarzach że cin>> wczytuje tylko jedno słowo i byłem zdziwiony tym faktem. I tak z ciekawości spytałem się, czy może ktoś spotkał się z tym faktem. Ciekawską jest to jak zamienię argumenty

ssdane >> this->grubosc>> this->name ;  To kompilator wyrzuca mi błąd że nie może przekształcić *char na int. Oczywiście mogę string obrobić w tradycyjny sposób stoi() itd.., ale może przy okazji bym się czegoś dowiedział.
komentarz 6 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Bardziej podejrzewam kompilator c::b, że domyślnie mi jakieś swoje modrości dołożył.

Oj tam, oj tam, od razu kompilator winny -> link

 

komentarz 6 czerwca 2019 przez niezalogowany
edycja 6 czerwca 2019

niestety nie działa

#include <iostream>
#include <iomanip>
#include <set>
#include <string>
#include <sstream>
#define fo(x) std::cout<<(#x)<<"="<<(x)<<std::endl;
#define co(x) std::cout<<(x)<<std::endl;
#define fo2(x,y) std::cout<<(#x)<<"="<<(x)<<"\t"<<(#y)<<"="<<(y)<<std::endl;

//template<typename T> void p(const T &arg){    std::cout<< arg << '\n';   }
// template<typename T, typename ... Args> void p(const T &arg, const Args& ... args){    std::cout<< arg << '\t';    p(args...);}

struct a {
    std::string name;
    int grubosc;

   static  std::set<std::string>a_typ;

  a( std::string n="" ,int g=18 )
        :name(std::move(n)), grubosc(g)
    {
             std::string gruboscString="";
             std::string temp = this->name+" "+std::to_string(g);
             a_typ.insert(std::move(temp));
    }

        a(bool =1,const std::string dane="" )
    {
            std::istringstream ssdane(dane);
            ssdane >> this->grubosc>> this->name ;
            std::string temp = this->name+" "+std::to_string(this->grubosc);
           fo2(name,grubosc);
             a_typ.insert(std::move(temp));
    }

    ~a(){}

        void   wy ()
    {
        fo(name)
        fo(grubosc)
    }
};

std::set<std::string> a::a_typ;

using namespace std;
int main() {
    cout << "Hello world!" << endl;
   a aa[]={{"a",1},{"b",1},{"c",3},{"a",1},{"e",5}};
   a bb{"b 3"};

  for (auto &x:aa ) x.wy();
  co("---------------------------------------")

for(auto &x:aa[0].a_typ) fo(x)
    return 0;
 co("---------------------------------------")

for(auto &x:aa[0].a_typ) {};

    return 0;
}


wyjście

Hello world!
name=   grubosc=0
name=a
grubosc=1
name=b
grubosc=1
name=c
grubosc=3
name=a
grubosc=1
name=e
grubosc=5
---------------------------------------
x= 0
x=a 1
x=b 1
x=c 3
x=e 5

komentarz 6 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Wiesz, że to :

a bb{"2222 b"};

wywołuje ten konstruktor:

a( std::string n="" ,int g=18 )

?

 

 

 

komentarz 6 czerwca 2019 przez niezalogowany
edycja 6 czerwca 2019

Sorry jednak nie działa;

#include <iostream>
#include <iomanip>
#include <set>
#include <string>
#include <sstream>
#define fo(x) std::cout<<(#x)<<"="<<(x)<<std::endl;
#define co(x) std::cout<<(x)<<std::endl;
#define fo2(x,y) std::cout<<(#x)<<"="<<(x)<<"\t"<<(#y)<<"="<<(y)<<std::endl;

//template<typename T> void p(const T &arg){    std::cout<< arg << '\n';   }
// template<typename T, typename ... Args> void p(const T &arg, const Args& ... args){    std::cout<< arg << '\t';    p(args...);}

struct a {
    std::string name;
    int grubosc;

   static  std::set<std::string>a_typ;

  a( std::string n="" ,int g=0)
        :name(std::move(n)), grubosc(g)
    {
             std::string gruboscString="";
             std::string temp = this->name+" "+std::to_string(g);
             if(g==0){
                  std::istringstream ssdane(name);
            ssdane >> this->grubosc>> this->name ;
            std::string temp = this->name+" "+std::to_string(this->grubosc);
           fo2(name,grubosc);
             }
             a_typ.insert(std::move(temp));
    }

    ~a(){}

        void   wy ()
    {
        fo(name)
        fo(grubosc)
    }
};

std::set<std::string> a::a_typ;

using namespace std;
int main() {
    cout << "Hello world!" << endl;
   a aa[]={{"a",1},{"b",1},{"c",3},{"a",1},{"e",5}};
   a bb{"b 222"};


  for (auto &x:aa ) x.wy();
  co("---------------------------------------")

for(auto &x:aa[0].a_typ) fo(x)
    return 0;
 co("---------------------------------------")

for(auto &x:aa[0].a_typ) {};

    return 0;
}


wyście

Hello world!
name=b 222      grubosc=0
name=a
grubosc=1
name=b
grubosc=1
name=c
grubosc=3
name=a
grubosc=1
name=e
grubosc=5
---------------------------------------
x=a 1
x=b 1
x=b 222 0 //b "222 nazwa" this->grubosc =0
x=c 3
x=e 5

pół dnia z tym walczyłem i się podałem konstruktor z samym stringiem tez nie działał o ile dobrze pamiętam,

komentarz 6 czerwca 2019 przez j23 Mędrzec (194,920 p.)
Nie działa, bo strumieniem pobierasz najpierw grubość, później nazwę, a w argumencie podajesz odwrotnie.

Linię 23 powinieneś przesunąć przed 30. Linię 27 usunąć.
komentarz 6 czerwca 2019 przez niezalogowany

ok, działa ale był jeszcze jeden błąd

 a( std::string n="" ,int g=0)
        :name(std::move(n)), grubosc(g)
    {
             std::string gruboscString="";
             std::string temp = this->name+" "+std::to_string(g);
             if(g==0){
                  std::istringstream ssdane(name);
            ssdane >> this->grubosc>> this->name ;
            std::string  // to pewnie mi krwi napsuło
temp = this->name+" "+std::to_string(this->grubosc); // a to już działa elegancko
           fo2(name,grubosc);
             }
             a_typ.insert(std::move(temp));
    }

 

komentarz 6 czerwca 2019 przez niezalogowany
dzięki właśnie to zrobiłem jak tylko zobaczyłem wynik w klasie.

a błąd ssdane >> this->grubosc>> this->name ; // wynikał z próby przeładoawania konstruktora a(int,string), a(string) bo a(string="",int=0), a(string) powodował błąd kompilacji
komentarz 6 czerwca 2019 przez j23 Mędrzec (194,920 p.)

Uprościłem nieco ten konstruktor:

a(std::string n = "", int g = 0)
    : grubosc(g)
{
    if (g == 0) std::istringstream(n) >> grubosc >> name;
    else name = std::move(n);
    a_typ.insert(name + " " + std::to_string(g));
}

 

komentarz 6 czerwca 2019 przez niezalogowany
wygląda lux

Zaloguj lub zarejestruj się, aby odpowiedzieć na to pytanie.

Podobne pytania

0 głosów
0 odpowiedzi 89 wizyt
0 głosów
1 odpowiedź 223 wizyt
pytanie zadane 30 czerwca 2019 w Sprzęt komputerowy przez Grz3siu Nowicjusz (120 p.)
0 głosów
1 odpowiedź 129 wizyt
pytanie zadane 27 grudnia 2018 w C i C++ przez XezolPL Obywatel (1,530 p.)

92,451 zapytań

141,261 odpowiedzi

319,073 komentarzy

61,853 pasjonatów

Motyw:

Akcja Pajacyk

Pajacyk od wielu lat dożywia dzieci. Pomóż klikając w zielony brzuszek na stronie. Dziękujemy! ♡

Oto polecana książka warta uwagi.
Pełną listę książek znajdziesz tutaj.

Akademia Sekuraka

Akademia Sekuraka 2024 zapewnia dostęp do minimum 15 szkoleń online z bezpieczeństwa IT oraz dostęp także do materiałów z edycji Sekurak Academy z roku 2023!

Przy zakupie możecie skorzystać z kodu: pasja-akademia - użyjcie go w koszyku, a uzyskacie rabat -30% na bilety w wersji "Standard"! Więcej informacji na temat akademii 2024 znajdziecie tutaj. Dziękujemy ekipie Sekuraka za taką fajną zniżkę dla wszystkich Pasjonatów!

Akademia Sekuraka

Niedawno wystartował dodruk tej świetnej, rozchwytywanej książki (około 940 stron). Mamy dla Was kod: pasja (wpiszcie go w koszyku), dzięki któremu otrzymujemy 10% zniżki - dziękujemy zaprzyjaźnionej ekipie Sekuraka za taki bonus dla Pasjonatów! Książka to pierwszy tom z serii o ITsec, który łagodnie wprowadzi w świat bezpieczeństwa IT każdą osobę - warto, polecamy!

...