Wszystko

Najlepsze

Archiwum

M.....L
  • 2
C# jest językiem zarządzanym (managed language, googlaj :), C nim nie jest. Poza tym mówiąc zwykle o C# mamy na myśli nie goły język ale cały potężny .NET Framework. Spokojnie możesz zacząć od C#. Łatwiejszy na początek a i tak bardzo wiele Cię nauczy. Z resztą, z C# łatwiej jest się przesiąść na jakby nie patrzeć - popularną Javę.
sylwke3100
  • 4
Jaki silnik graniczny 3D polecacie do stworzenia prostego symulatora takiego że jakiś obiekt (załadowany z pliku 3ds lub innych) będzie poruszał się po torze w jakiejś mapce (również załadowany z jakiegoś pliku) ? Format załadowanych plików najlepiej byłby taki żeby łatwo go można edytować pod jakimiś programami pod linuksem.

Istotne jest to żeby był w miarę łatwy do ogarnięcia.

#programowanie #cpp #silniki3d
KrzaQ2
  • 8
@lukaszmaly254366: Przekazywanie przez wartość wiąƶe się z wykonaniem kopii, co dla większych obiektów jest znacząco wolniejsze, dlatego "zasada kciuka" mówi, abyś kaƶdy argument przyjmował przez

const&
. Jednak dla obiektów o małej wielkości, wydajniej jest przekazać wartość niƶ referencję, która jest de facto wskaźnikiem i kompilator nie moƶe tego wydajnie zoptymalizować (source).
KrzaQ2
  • 4
@sylwke3100: Benchmarki to benchmarki, zawsze się nadadzą, ale, jeśli chcesz zmierzyć koszt przekazania argumentu do funkcji to powinieneś:

1. Testować z włączonymi optymalizacjami

2. Zniwelować ryzyko zinline'owania przez kompilator testowanej funkcji (umieszczenie tego w tym samym TU bez compiler-specific wstawek praktycznie to gwarantuje)

3. Zniwelować szansę na LTO

4. Sprawdzić więcej przypadków (pusty/mały/średni/ogromny wektor przez ref/wartość, typy wbudowane przez ref/wartość)
psi-nos
  • 1
Chcę przeciążyć operator strumieniowy << dla klasy z szablonem:

(tablica.h)



template
```**```
<
```**```
class
```**```
 T> 
```**```
class
```**```
 Tablica
``````
{
``````
public:
``````
        T * elementy;
``````
        
```**```
size_t
```**```
 n_elementow;
``````
        
```**```
friend
```**```
 ostream & 
```**```
operator
```**```
<<(ostream &strumien, 
```**```
const
```**```
 Tablica & tablica);
``````
};
``````
(tablica.cpp)
``````
ostream & 
```**```
operator
```**```
<< (ostream &strumien, 
```**```
const
```**```
 Tablica &tablica)
``````
{
``````
...
``````
}
Tylko, że w tablica.cpp nie
KrzaQ2
  • 2
@Rincewind: to nie do końca tak jest, ale jako uproszczona wersja ok.

@psi-nos: Funkcja teƶ musi być szablonowa, więc w .cpp (albo lepiej w nagłówku) to powinno wyglądać tak:



template
```**```
 <
```**```
typename
```**```
 T>
``````
ostream & 
```**```
operator
```**```
<< (ostream &strumien, 
```**```
const
```**```
 Tablica &tablica)
sylwke3100
  • 3
Nie wie ktoś czy w makrze

BOOST_CHECK/BOOST_CHECK_EQUAL
można porównywać vectory niestandardowe?

Jeśli tak to jak to zrobić bo standardowo mi nie przechodzi tylko wywala błąd

/usr/include/c++/4.8/bits/stlalgobase.h:797: error: passing 'const Colors' as 'this' argument of 'bool Colors::operator==(Colors)' discards qualifiers [-fpermissive]

if (!(*first1 == *first2))

#programowanie #cpp #boost
k.....r
  • 1
@nCore: ja kiedys pisalem takiego na strumieniach, w ktorym mozna bylo formatowac wysjcie, np.

LOG() << "Title" << kmu::table(3, 3) << 1 << 2 << 3 << "a" << "b" << "c " << "A" << "B" << "C"<< ...
, ktory ladnie formatowal wyjscie, ale jakos szybko mi sie odechcialo...
KrzaQ2
  • 1
@kuhar: Mamy takie coś w projekcie, ale dopasowanie tego do manipulatorów z iostream to masakra, więc skończyło się na tym, ƶe budujemy stringstream, a do loggera wysyłamy gotowy string. Łatwo, wygodnie, standardowo i thread-safe.
psi-nos
  • 3
To

void rozmiar(char * tablica, size_t n_elementow, size_t n_elementow_nowe)_
_
{_
_
tablica=new char[n_elementow_nowe];_
_
for(int i=(n_elementow-1); i
tablica[i]=33;

}

int main()

{

char * test;

test = new char[6];

rozmiar(test, 6, 12);

}
powinno (przynajmniej wg. mnie :P) zwiększyć tablicę (do 12) i nowe elementy wypełnić 33 (czyli znakami wykrzykniku), ale po wyświetleniu mają 0. Co robię źle?

#programowanie #cpp

`
kasper93
  • 4
#programowanie #cpp #mfc

Mam taki problemik, głowię się jak sprytnie zaimplementować listę ustawień, taką jak w uTorrent (advanced settings).

Tylko teraz jest problem bo mam trzy różne typy danych string, int, bool. Ale chciałbym to zrobić jak najbardziej zwięźle, czyli nie robić osobnych case dla każdego ustawienia i przepisywać ten sam kod wszędzie.

Myślałem, żeby zrobić szablon struktury konkretnego ustawienia i dodać do listy wskaźnik na tę strukturę, ale ostatecznie musiał bym
hbpitero
  • 2
@kasper93: Mocno mieszasz tutaj poziomy abstrakcji, mówisz o liście ustawień (całym jakby komponencie), a zaraz o case, wskaźnikach itd. i robieniu "na piechotę". czy przez robienie na piechotę masz na myśli kopiowanie kodu 100x? Przecież można zrobić na piechotę (także z case) a dobrze.

Zrobiłbym po prostu kontener "czegoś co można ustawiać" z poszczególnymi "opcjami" konkretnego typu, oprogramować to uniwersalnie, dzięki czemu stworzenie takich ustawień ostatecznie powinno wyglądać na coś w
L24D
  • 4
Cześć! Mam za zadanie znaleźć takie liczby A,B,C typu double dla których nie zachodzi prawo łączności (A+B)+C = A+(B+C). Wiem że dla liczb zmiennoprzecinkowych nie zawsze ono zachodzi (ograniczenia arytmetyki zmiennoprzecinkowej), jednak w programie podając nawet szalone liczby typu 25.0e+30, 0.03e-40, -1e-30 wszystko liczy idealnie :/

Piszę w C++ i jakoś za cholerę nie mogę znaleźć takich liczb żeby zaszło jakieś zaokrąglenie, etc.

Co na to poradzić?

#programowanie #problem #cpp #metodynumeryczne
Drzwi
  • 1
Co będzie lepsze (chociaż wolałbym prostsze) od wektorów? Muszę jakoś trzymać wszystkie obiekty klas w kupie, mam iteratory i dużo fajnych narzędzi do działania na nich, ale łatwo tutaj o wycieki pamięci.

I zastanawiam się czy dobrze (i zgodnie z pryncypiami OO) robię, jeśli mój kod działa na zasadzie - klasa bazowa ze zmiennymi ją opisującymi i podstawowymi getterami i setterami i dziedzicząca od niej klasa zarządzająca, w której znajduje się wektor
O.....i
  • 2
@Drzwi: Tak ogólnie rzecz biorąc, to wektor jest zdecydowanie najprostszym możliwym kontenerem właśnie dlatego, że symuluje zwykłe tablice. Czyli nie musisz korzystać w ogóle z iteratorów, wystarczy operator wyłuskania []. No, może przydają się do algorytmów standardowych, ale to jest trywialne. Przykład sortowania:

sort(v.begin(), v.end());
Natomiast jeśli chodzi o Twoje zadanie, to ja tam szczerze powiedziawszy nie widzę miejsca na dziedziczenie. Ta BaseMenager wygląda mi na coś w rodzaju adaptera, ale

Powiązane tagi

Popularne tagi