Jeśli mam 100 obiektów to można je jakoś inaczej włożyć do wektora niż ręcznie każdy pojedyńczo?
0
0
W nowym standardzie C++ można tak:
vector<int> wektor{1,2,4}
Ale czy w starszej wersji jest coś podobnego?
1
a gdzie sa te obiekty? jak sa zdefiniowane? Dlaczego nowego standardu nie mozna uzyc?
Moze jakies konkrety?
0
Mam klasę obiektów i chcę je włożyć do wektora. W zasadzie to mógłbym użyć i nowego standardu. Tylko nie bardzo się orientuje jak mam code blocksa po c++98 to jak zaaktualizować pod C++11
1
to je włóż skoro masz klase obiektów.
http://fasadin.4programmers.net/2016/02/blog-post.html
tutaj masz jak wlaczyc opcje dla nowego standardu pod sekcja 0.2
polecam tez 0.3
0
Co to znaczy klasa obiektów? Pokaż kod bo to wyrażenie niewiele mówi.
0
Musisz to zrobić ręcznie i to bez copy-paste programming.
Jesteś zaznajomiony z ideą pętli?
0
Mam klasę przedmiotów i chce te przedmioty umieścić w wektorze.
0
no to je wloz, ja nie widze problemu
Nikt tutaj nie jest wrozbita i bez kodu nikt Ci wiecej nie powie.
3
Mam klasę obiektów
Co to znaczy klasa obiektów
Mam klasę obiektów
Weź tu pogadaj i próbuj pomóc.
0
class Towar
{
protected:
double cena;
string nazwa;
public:
Towar(string nazwa)
{
this->cena = 0;
this->nazwa = nazwa;
}
virtual void koszt()
{
}
};
I jeśli stworzę np.100 obiektów to potem je ręcznie do wektora wstawiać?
2
tworz od razu w vectorze
std::vector<std::unique_ptr<Towar>> myVec;
for (int i = 0 ; i < 100; i++)
{
myVec.push_back(std::make_unique<Towar>(to_string(i)));
}
2
Czarny Pomidor napisał(a):
Jeśli mam 100 obiektów to można je jakoś inaczej włożyć do wektora niż ręcznie każdy pojedyńczo?
Jeśli masz 100 obiektów, to zakładam, że masz jakieś źródło danych (plik, sieć, kod generujący), a nie wpisane twardo w kodzie.
W takim wypadku należy zrobić to tak:
vector<TwojaKlasa> v; // albo: vector<shared_ptr<TwojaKlasa>> v;
v.reserve(100); // znacznie poprawia perfomance
TwojaKlasa x;
while(plik >> x} {
v.push_back(x);
}
Jest jeszcze std::back_inserter
0
Dobra ustawiłem już na c++11 w code:blockie i mogę w ten sposób inicjalizować wektor vector<int> wektor{1,4,7};
0
Chodzi o to, że chce stworzyć taki sklep w konsoli jednak na razie miałem zamiar po prostu stworzyć sporą ilość obiektów. Później ewentualnie spróbować utworzyć bazę danych, choć jeszcze nigdy tego nie robiłem. Czy sprawić aby za pomocą menu była możliwość dodawania Towaru?
0
Ok, nie potrafisz pisac konkretnie mimo pokazania palcem co powinienes zrobic to nie ma sensu (dla mnie) ciagnac tego dalej. Jak dasz konkretne informacje wtedy pomoge. Bo strzelanie na slepo nie jest fajne
0
Po prostu próbuje stworzyć sklep. Klasa podstawowa nazywa się Towar. Na razie mam dwie klasy pochodne Warzywo i Owoce. Na tej podstawie chciałem stworzyć obiekty klasy Warzywo i Owoce i utworzyć z nich wektory. Później utworzyć wektor klasy Towar aby mieć wszystkie Towary w jednym czyli owoce i warzywa. Planowałem właśnie stworzyć dodatkowo klasę Koszyk w którym bym trzymał ten wektor Towarów.
4
class Towar {
public:
virtual ~Towar () { }
};
class Owoc : public Towar { };
class Warzywo : public Towar { };
int main () {
std::vector <std::unique_ptr<Towar>> myVec;
myVec.reserve(100);
for (size_t i = 0; i < 50; ++i) {
myVec.push_back(std::unique_ptr<Towar>(new Owoc {}));
myVec.push_back(std::unique_ptr<Towar>(new Warzywo {}));
}
}
Skłaniałbym się raczej do takiego rozwiązania.
1
A nie lepiej po prostu zamieścić w klasie bazowej informacji o tym jaka jest ilość danego produktu? Nie zapełniać wektor setkami obiektów, które później będziesz musiał weryfikować czy są marchwią, truskawką czy śliwką?? Będziesz miał wektor towarów po jednym każdego rodzaju i wewnątrz danego rodzaju będzie od razu wiadomo ile go masz na magazynie:
#include<iostream>
#include<memory>
#include<vector>
using namespace std;
struct Towar{
unsigned ilosc;
Towar(unsigned ilosc):ilosc(ilosc){}
virtual ~Towar(){}
};
struct Marchew : public Towar{
Marchew(unsigned ilosc) : Towar(ilosc){}
};
struct Truskawka : public Towar{
Truskawka(unsigned ilosc) : Towar(ilosc){}
};
int main(){
vector<unique_ptr<Towar>> towary;
towary.push_back(unique_ptr<Towar>(new Marchew(10)));
towary.push_back(unique_ptr<Towar>(new Truskawka(5)));
return 0;
}
Ułatwi Ci to gospodarkę magazynową, bo przy usuwaniu po prostu zmniejszysz ilość danego produktu, zamiast usuwać go z gigantycznego wektora.
EDIT: patrz komentarz @spartanPAGE pod moim postem - mądrze człowiek mówi :)
2
(Bawiąc się troszkę w barwne tworzenie produktów...)
Pamiętaj jednak, że takie rzeczy nie powinny wprowadzać obiektowej hierarchii: zamiast tego powinny być to proste POD'y, które można łatwo wrzucić do bazy danych.
#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <limits>
using namespace std;
template<typename T>
struct single_field_struct_of{
T value;
};
using name_t = single_field_struct_of<string>;
using money_t = single_field_struct_of<size_t>;
struct product{
name_t name;
money_t price;
};
using amount_t = single_field_struct_of<size_t>;
using desc_t = single_field_struct_of<string>;
struct product_info {
amount_t amount;
desc_t desc;
product data;
};
int main() {
using products_t = vector<product_info>;
products_t products = {
product_info {
amount_t {10},
desc_t {"najsmaczniejsze!"},
product {
name_t {"truskawka"},
money_t {15}
}
},
product_info {
amount_t {15},
desc_t {"najtwardsze!"},
product {
name_t {"cegla"},
money_t {8}
}
}
};
return 0;
}
0
spartanPAGE napisał(a):
(Bawiąc się troszkę w barwne tworzenie produktów...)
Gdyby wreszcie dodali designated initializers do C++, to nie trzeba byłoby takich haków jak single_field_struct_of.
Kod w C:
#include <stddef.h>
struct product{
const char *name;
size_t price;
};
struct product_info {
size_t amount;
const char *desc;
struct product data;
};
int main() {
struct product_info products[] = {
{
.amount = 10,
.desc = "najsmaczniejsze!",
.data = {
.name = "truskawka",
.price = 15
}
},
{
.amount = 15,
.desc = "najtwardsze!",
.data = {
.name = "cegla",
.price = 8
}
}
};
return 0;
}