Time Lapse z 2014 roku - motzno polecam. Dawno się tak nie przejąłem akcją żadnego filmu.
Pokaż ukrytą treśćNie oglądajcie trailerów, nie czytajcie opisów - mogą sporo zdradzić!
@Zian: gorsi niż zwiastuny są ludzie, którzy mówią, że nie obejrzą filmu jeśli nie będą wiedzieli o czym jest ;)
Cieszę się, że się podobało coś poleconego przeze mnie! :D
https://www.youtube.com/watch?v=PDBjsKDagqk
Nagranie rozmowy telefonicznej z osobą uwięzioną w WTC 11.09.
2:35 - dyspozytorka doradza kobiecie znaleźć biurko i wspiąć się jak najwyżej, żeby uciec przed dymem.
ŁAT DA FAK?!
@Kaba___JK: wszystko może zależeć od wentylacji. No i powietrze jest chyba mniej gęste niż dym (nie mam pewności, ale dym leci do góry tylko dlatego, że ma większą temperaturę), więc powinno być go więcej przy suficie (?).
C++, "forward declarations"
Czy ktoś może mi to wytłumaczyć, bo ni cholery nie potrafię tego zrozumieć?
Myk polega na tym, żeby nie walić #include do każdego pliku, tylko napisać deklarację używanych w nim funkcji / klas. Ale nadal gdzieś musimy dać to #include mimo wszystko...
Załóżmy, że mamy takie przykładowe pliczki:
/ A.hpp /
class A {
public:
A();
B getB();
}
/ A.cpp /
#include "A.hpp"
A::A() {}
B A::getB() { B b; return b; }
/ B.hpp /
class B {
public:
B();
}
/ B.cpp /
#include "B.hpp"
B::B() {}
No i wszystko spoko, ale kiedy chcemy skorzystać z klasy A, musimy dać #include do pliku B.hpp:
/ main.cpp /
#include "A.hpp"
#include "B.hpp" // bez tego nie zadziała
int main () {
A a;
a.getB();
return 0;
}
Co nam to daje, że nie daliśmy tego wcześniej?
I jaki ma sens taki podział na pliki, skoro chcemy użyć tylko klasy A i nie powinno nas interesować, skąd A bierze B?
@onyx: spokojnie, wszystko już rozumiem dzięki Twoim wyjaśnieniom i linkom. Martwi mnie tylko ta niekonsekwencja w tym, gdzie umieszczamy dyrektywy #include :)
C++, "forward declarations"
Czy ktoś może mi to wytłumaczyć, bo ni cholery nie potrafię tego zrozumieć?
Myk polega na tym, żeby nie walić #include do każdego pliku, tylko napisać deklarację używanych w nim funkcji / klas. Ale nadal gdzieś musimy dać to #include mimo wszystko...
Załóżmy, że mamy takie przykładowe pliczki:
/ A.hpp /
class A {
public:
A();
B getB();
}
/ A.cpp /
#include "A.hpp"
A::A() {}
B A::getB() { B b; return b; }
/ B.hpp /
class B {
public:
B();
}
/ B.cpp /
#include "B.hpp"
B::B() {}
No i wszystko spoko, ale kiedy chcemy skorzystać z klasy A, musimy dać #include do pliku B.hpp:
/ main.cpp /
#include "A.hpp"
#include "B.hpp" // bez tego nie zadziała
int main () {
A a;
a.getB();
return 0;
}
Co nam to daje, że nie daliśmy tego wcześniej?
I jaki ma sens taki podział na pliki, skoro chcemy użyć tylko klasy A i nie powinno nas interesować, skąd A bierze B?
jak najmniej używam #include w pliku .hpp
@onyx: ale nadal czasem trzeba, np. w przypadku std::string. Więc jakieś tam #include w pliku nagłówkowym czasem się pojawi, a przez to robi się wg mnie drobny bałagan.
Zresztą popatrzmy na plik nagłówkowy ze standardowych bibliotek, np. iostream. Często są w nich #include dodawane...
@spam_only: chyba już mam :P
Jest niby to nouveau-fw, ale chyba dla mnie niczego nie zmienia?
Kolejny log, jakby Ci się chciało przeglądać :P
Dzięki za tego linka, zaraz przetestuję! Działa :D
@Kokofon: reszta świata nie ma problemu z nazywaniem Włochów italianami, ale czy nam to przeszkadza? :D
C++, "forward declarations"
Czy ktoś może mi to wytłumaczyć, bo ni cholery nie potrafię tego zrozumieć?
Myk polega na tym, żeby nie walić #include do każdego pliku, tylko napisać deklarację używanych w nim funkcji / klas. Ale nadal gdzieś musimy dać to #include mimo wszystko...
Załóżmy, że mamy takie przykładowe pliczki:
/ A.hpp /
class A {
public:
A();
B getB();
}
/ A.cpp /
#include "A.hpp"
A::A() {}
B A::getB() { B b; return b; }
/ B.hpp /
class B {
public:
B();
}
/ B.cpp /
#include "B.hpp"
B::B() {}
No i wszystko spoko, ale kiedy chcemy skorzystać z klasy A, musimy dać #include do pliku B.hpp:
/ main.cpp /
#include "A.hpp"
#include "B.hpp" // bez tego nie zadziała
int main () {
A a;
a.getB();
return 0;
}
Co nam to daje, że nie daliśmy tego wcześniej?
I jaki ma sens taki podział na pliki, skoro chcemy użyć tylko klasy A i nie powinno nas interesować, skąd A bierze B?
@onyx: no ale właśnie, skoro nie może założyć z góry jak duży jest wskaźnik, to nadal mu nic nie daje... Dlatego nadal nie rozumiem, jak ma się zmniejszyć czas kompilacji, skoro jedyne co kompilatorowi zapewniamy to rozróżnienie czym jest dany symbol... Nie widzę żadnych plusów z używania niekompletnych deklaracji, za to widzę same minusy - np. niektóre #include w plikach .cpp zamiast .hpp, nie wiadomo gdzie ich szukać w kodzie...
C++, "forward declarations"
Czy ktoś może mi to wytłumaczyć, bo ni cholery nie potrafię tego zrozumieć?
Myk polega na tym, żeby nie walić #include do każdego pliku, tylko napisać deklarację używanych w nim funkcji / klas. Ale nadal gdzieś musimy dać to #include mimo wszystko...
Załóżmy, że mamy takie przykładowe pliczki:
/ A.hpp /
class A {
public:
A();
B getB();
}
/ A.cpp /
#include "A.hpp"
A::A() {}
B A::getB() { B b; return b; }
/ B.hpp /
class B {
public:
B();
}
/ B.cpp /
#include "B.hpp"
B::B() {}
No i wszystko spoko, ale kiedy chcemy skorzystać z klasy A, musimy dać #include do pliku B.hpp:
/ main.cpp /
#include "A.hpp"
#include "B.hpp" // bez tego nie zadziała
int main () {
A a;
a.getB();
return 0;
}
Co nam to daje, że nie daliśmy tego wcześniej?
I jaki ma sens taki podział na pliki, skoro chcemy użyć tylko klasy A i nie powinno nas interesować, skąd A bierze B?
@onyx: dzięki Ci dobry człowiecze <3
Co do trzeciego linka:
an address is an address, regardless of what kind
of thing is at that address, and addresses are always the same size regardless of what they point t
Wskaźniki na funkcje / metody nie zawsze są takiego samego rozmiaru jak wskaźniki na zwykłe obiekty. Więc to trochę dziwne założenie dla mnie...
@Jezor mnie blokuje przez co nie mogę odpisać duxetowi żeby usunął konto
@duxet:
C++, "forward declarations"
Czy ktoś może mi to wytłumaczyć, bo ni cholery nie potrafię tego zrozumieć?
Myk polega na tym, żeby nie walić #include do każdego pliku, tylko napisać deklarację używanych w nim funkcji / klas. Ale nadal gdzieś musimy dać to #include mimo wszystko...
Załóżmy, że mamy takie przykładowe pliczki:
/ A.hpp /
class A {
public:
A();
B getB();
}
/ A.cpp /
#include "A.hpp"
A::A() {}
B A::getB() { B b; return b; }
/ B.hpp /
class B {
public:
B();
}
/ B.cpp /
#include "B.hpp"
B::B() {}
No i wszystko spoko, ale kiedy chcemy skorzystać z klasy A, musimy dać #include do pliku B.hpp:
/ main.cpp /
#include "A.hpp"
#include "B.hpp" // bez tego nie zadziała
int main () {
A a;
a.getB();
return 0;
}
Co nam to daje, że nie daliśmy tego wcześniej?
I jaki ma sens taki podział na pliki, skoro chcemy użyć tylko klasy A i nie powinno nas interesować, skąd A bierze B?
C++, "forward declarations"
Czy ktoś może mi to wytłumaczyć, bo ni cholery nie potrafię tego zrozumieć?
Myk polega na tym, żeby nie walić #include do każdego pliku, tylko napisać deklarację używanych w nim funkcji / klas. Ale nadal gdzieś musimy dać to #include mimo wszystko...
Załóżmy, że mamy takie przykładowe pliczki:
/ A.hpp /
class A {
public:
A();
B getB();
}
/ A.cpp /
#include "A.hpp"
A::A() {}
B A::getB() { B b; return b; }
/ B.hpp /
class B {
public:
B();
}
/ B.cpp /
#include "B.hpp"
B::B() {}
No i wszystko spoko, ale kiedy chcemy skorzystać z klasy A, musimy dać #include do pliku B.hpp:
/ main.cpp /
#include "A.hpp"
#include "B.hpp" // bez tego nie zadziała
int main () {
A a;
a.getB();
return 0;
}
Co nam to daje, że nie daliśmy tego wcześniej?
I jaki ma sens taki podział na pliki, skoro chcemy użyć tylko klasy A i nie powinno nas interesować, skąd A bierze B?
sorry za formatowanie tekstu, ale na strimoidzie jest zjebane i nie da się kilku linijek dać jako kod...
Kiedy się loguję, odpalają mi się dwie sesje naraz. XFCE i openbox. Żeby przejść do openboxa muszę się wylogować... Halp ;_;
@Kuraito: na łindousie mam wyłączone aktualizacje w ogóle, bo każda się kończy albo rollbackiem albo instalacją systemu od nowa ;]
Kiedy się loguję, odpalają mi się dwie sesje naraz. XFCE i openbox. Żeby przejść do openboxa muszę się wylogować... Halp ;_;
#!/bin/sh
#
# ~/.xinitrc
#
# Executed by startx (run your window manager from here)
#
export GTK2_RC_FILES="$HOME/.gtkrc-2.0"
DEFAULT_SESSION=xfce4-session
case $1 in
xfce) exec dbus-launch xfce4-session ;;
openbox) exec dbus-launch openbox-session tint2 ;;
*) exec dbus-launch $DEFAULT_SESSION ;;
esac
Wygląda jak wyglądało wcześniej właśnie.