Byla vydána nová stabilní verze 6.7 webového prohlížeče Vivaldi (Wikipedie). Postavena je na Chromiu 124. Přehled novinek i s náhledy v příspěvku na blogu. Vypíchnout lze Spořič paměti (Memory Saver) automaticky hibernující karty, které nebyly nějakou dobu používány nebo vylepšené Odběry (Feed Reader).
OpenJS Foundation, oficiální projekt konsorcia Linux Foundation, oznámila vydání verze 22 otevřeného multiplatformního prostředí pro vývoj a běh síťových aplikací napsaných v JavaScriptu Node.js (Wikipedie). V říjnu se verze 22 stane novou aktivní LTS verzí. Podpora je plánována do dubna 2027.
Byla vydána verze 8.2 open source virtualizační platformy Proxmox VE (Proxmox Virtual Environment, Wikipedie) založené na Debianu. Přehled novinek v poznámkách k vydání a v informačním videu. Zdůrazněn je průvodce migrací hostů z VMware ESXi do Proxmoxu.
R (Wikipedie), programovací jazyk a prostředí určené pro statistickou analýzu dat a jejich grafické zobrazení, bylo vydáno ve verzi 4.4.0. Její kódové jméno je Puppy Cup.
IBM kupuje společnost HashiCorp (Terraform, Packer, Vault, Boundary, Consul, Nomad, Waypoint, Vagrant, …) za 6,4 miliardy dolarů, tj. 35 dolarů za akcii.
Byl vydán TrueNAS SCALE 24.04 “Dragonfish”. Přehled novinek této open source storage platformy postavené na Debianu v poznámkách k vydání.
Oznámeny byly nové Raspberry Pi Compute Module 4S. Vedle původní 1 GB varianty jsou nově k dispozici také varianty s 2 GB, 4 GB a 8 GB paměti. Compute Modules 4S mají na rozdíl od Compute Module 4 tvar a velikost Compute Module 3+ a předchozích. Lze tak provést snadný upgrade.
Po roce vývoje od vydání verze 1.24.0 byla vydána nová stabilní verze 1.26.0 webového serveru a reverzní proxy nginx (Wikipedie). Nová verze přináší řadu novinek. Podrobný přehled v souboru CHANGES-1.26.
Byla vydána nová verze 6.2 živé linuxové distribuce Tails (The Amnesic Incognito Live System), jež klade důraz na ochranu soukromí uživatelů a anonymitu. Přehled změn v příslušném seznamu. Tor Browser byl povýšen na verzi 13.0.14.
Byla vydána nová verze 30.0.0 frameworku pro vývoj multiplatformních desktopových aplikací pomocí JavaScriptu, HTML a CSS Electron (Wikipedie, GitHub). Chromium bylo aktualizováno na verzi 124.0.6367.49, V8 na verzi 12.4 a Node.js na verzi 20.11.1. Electron byl původně vyvíjen pro editor Atom pod názvem Atom Shell. Dnes je na Electronu postavena celá řada dalších aplikací.
#include <stdio.h>
#define N(a) (sizeof(a) / sizeof(a[0]))
void f1(char *s);
void f2(void);
void f3(char *s1, char *s2);
int main()
{
int i;
char *strings[] = {"Hello", NULL, "World"};
void (*array_pf[])() = {f1, f2, f3};
for (i = 0; i < N(array_pf); i++)
(*array_pf[i])(strings[i], "!!!\n");
return 0;
}
void f1(char *s)
{
printf("%s", s);
}
void f2(void)
{
printf(" ");
}
void f3(char *s1, char *s2)
{
printf("%s%s", s1, s2);
}
Tiskni Sdílej:
void (*array_pf[])(char *, char *) = {f1, f2, f3};Takže toho tučňáka byste mi měli odebrat
Ten termín jsem potkal ve slovenském překladu K&R, kde ho používali dost důsledně, ale netuším, jestli se opravdu ujal.
který se napojuje „rúrami“
Těmito? :-)
Tyhle jsem myslel.
To mi došlo - jenže právě tomu v té knize říkali dátovod.
Já bych spíše řekl, že tohle je prasárna, protože jsem neuvedl typ argumentů v deklaraci ukazatele na funkci.Ale uviedol, všimni si, čo je počiarknuté.
void (*array_pf[])() = {f1, f2, f3};
To znamená, že odkaz na funkciu bude bez perametrov. V najnižšej hardvérovej úrovne je funkcia len adresa, na ktorú skočí vykonavať procesor program. Parametre funkcie hovoria, že čo sa spraví zo zásobníkom. O ich prípravu, uloženie, mazanie sa stará prekladač.
A pri
void (*array_pf[])(char *, char *) = {f1, f2, f3};
už očakáva, že prvy poľa budu smerniky na funkciu s 2 dvoma parametrami.
A ignorovať paramatre (zásobnika) funkcií vieš. Naopak už to je iné.
#include <stdio.h> #include <stdarg.h> #define N(a) (sizeof(a) / sizeof(a[0])) void f1(char *s, ...); void f2(char *s, ...); void f3(char *s, ...); int main() { int i; char *strings[] = {"Hello", NULL, "World"}; void (*array_pf[])(char *, ...) = {f1, f2, f3}; for (i = 0; i < N(array_pf); i++) (*array_pf[i])(strings[i], "!!!\n", 42); return 0; } void f1(char *s, ...) { printf("%s", s); } void f2(char *s, ...) { printf(" "); } void f3(char *s1, ...) { va_list pa; va_start(pa, s1); printf("%s%s", s1, va_arg(pa, char*)); printf("%d", va_arg(pa, int)); va_end(pa); }
Parametre funkcie hovoria, že čo sa spraví zo zásobníkom.To neni zaruceno. Vyuzivas toho, ze argumenty se vzdy predavaji v urcitem presne danem poradi bez znalosti prototypu funkce. Napriklad u ABI procesoru ARM je zaludnost v tom, ze pokud mas beznou funkci, tak hodnoty typu double/float se predavaji v odpovidajicich floating-point registrech, pokud je to variadicka funkce (napr. printf) tak se tyto hodnoty predavaji v beznych general-purpose registrech. Jinymi slovy, pokud budes provadet takove pretypovani, pouzijes odkaz na printf a nejaky double/float, nebude to fungovat.
f() - To znamená, že odkaz na funkciu bude bez perametrovNikoliv, to se v C řekne f(void). f() znamená, že to má nějaké neurčité argumenty, které se budou předávat podle pravidel pro varargs, čili jako kdyby tam bylo f(...).
f()
je "old-style" deklarace a máš pravdu, že má neurčité argumenty (kompilátor z toho neví typ/počet), ale s varargs to nemá vůbec nic společného. f(...)
je něco jiného.
Funkce se v C může volat s libovolným počtem parametrů a vezme si jen ty, které deklaruje?Ne! On ty funkce přetypoval. IIRC to, co udělal, vede dle standardu k UB (undefined behaviour) a může vést k nečekaným vedlejším účinkům. Například, jaké číslo vytiskne následující program?
#include <stdio.h>
void __attribute__((noinline)) foobar(long a, long *p1) {
*p1 += a;
}
int main(int argc, char const *argv[])
{
long x = 0;
void (*bastardized)(long) = foobar;
foobar(1, &x);
bastardized(1);
printf("%ld\n", x);
return 0;
}
Po přeložení gcc -O2 -S
na x86-64:
main:
subq $24, %rsp
movl $1, %edi
leaq 8(%rsp), %rsi
movq $0, 8(%rsp)
call foobar
movl $1, %edi
call foobar
movq 8(%rsp), %rsi
movl $.LC0, %edi
xorl %eax, %eax
call printf
xorl %eax, %eax
addq $24, %rsp
ret
Čiliže tohle je něco, co by se rozhodně nemělo dělat
On ty funkce přetypoval.Kde? Na tomhle řádku jsou bez parametru:
void (*array_pf[])() = {f1, f2, f3};A tady je všechny volá se dvěma parametry:
(*array_pf[i])(strings[i], "!!!\n");A funkce ignorují parametry, které nedeklarovaly. Zkoušel jsem to zkompilovat a spustit – funguje to a nevypisuje jediné varování.
void (*ptr)();
ptr(1, 2, 3);
Nebo třeba:
float f = 3.14;
int *i = &f;
Btw. C++ kompilátor tyhle implicitní konverze odmítne, tam by se musel udělat reinterpret_cast()
.
A funkce ignorují parametry, které nedeklarovaly. Zkoušel jsem to zkompilovat a spustit – funguje to a nevypisuje jediné varování.Ano, ale to je pouze šťastná náhoda, že ta dotyčná funkce nedělá nic s příslušnýma registrama a práce se stackem je taky zrovna náhodou kompatibilní. Nic z toho nemusí platit na jiné architektuře nebo třeba jen s jiným kompilátorem nebo nastavením. Když např. v tom kódu z n blogu upravim funkci
f1
takhle:
void f1(char *s, char *s2, void (*ptr)(char *))
{
printf("%s\n", s);
char *str = "Wtf, why is this string printed?";
if (s != str) ptr(str);
}
"Funguje" mi to na x86-64 při přeložení pomocí gcc -O0
a gcc -O2
(protože úplnou náhodou funkce main ten třetí parametr jakoby nastavuje, resp. používá stejný registr pro procházení tím polem), už to ale nefunguje s clangem nebo gcc -O1
.
dint &= (dint - 1);volanou ve smyčce. Taky dobrej hack (schválně zda to někdo popíše z hlavy, já si to musel rozepsat cyklus po cyklu).
x & (x - 1)
" považuju za standardní idiom (zejména když se výsledek použije jako bool). :-)
include/linux/log2.h
:
static inline __attribute__((const)) bool is_power_of_2(unsigned long n) { return (n != 0 && ((n & (n - 1)) == 0)); }
Má to konstantní časovou složitost a lze to použít i v preprocesoru - viz makro BUILD_BUG_ON_NOT_POWER_OF_2()
.
721 while (dint) { 722 i = __ffs(dint); 723 dint &= (dint - 1); 724 phy = &pdev->phys[i];Mě právě překvapilo, že se nepoužilo vymaskování tou nalezenou jedničkou nebo ještě líp maskování 1<<[0..31], ale co já vím, možná to ARM dokáže nacpat do jedné instrukce .
Ta instrukce nevrátí tu nalezenou jedničku, ale její index, takže byste musel udělat něco jako
dint &= ~(1 << i)
tj. tři instrukce - a to si ještě nejsem jistý, jestli ten shift nebude pomalejší než bitové operace nebo odečtení jedničky.
ono záleží na architektuře. Některý umí NAND instrukci
Je brzy ráno, neměl jsem ještě kafe, tak se dám se poddat: jak by mi v tomto konkrétním případě pomohla?
x = a AND NOT b
BTW: Jsou tyhle konstrukce/idiomy někde zdokumentovanéJj: Bit Twiddling Hacks.
Částečně se to dá přirovnat k návrhovým vzorůmNééé, jen to ne. Technicky máš samozřejmě pravdu, dá se to k tomu přirovnat, ale byl bych radši, kdyby C zůstalo kargokultu tzv. návrhových vzorů ušetřeno...
Jsou tyhle konstrukce/idiomy někde zdokumentované nebo se počítá s tím, že tomu případný čtenář bude rozumět?Treba:
a & (a ^ (a - 1))
" na iteráciu.
void (*array_pf[])() = {f1, f2, f3};
je temná magie, kterou když pochopíš, tak umíš ¾ jazyka C.
10 FOR A = 100 TO 300 STEP 100 20 GOSUB A 30 NEXT A 40 END 100 REM f1 110 PRINT "Hello" 120 RETURN 200 REM f2 210 PRINT " " 220 RETURN 300 REM f3 310 PRINT "World!!!" 320 RETURNakorát Céčko už je natolik pokročilý jazyk z budoucnosti že vše nejsou čísla řádků, ale adresy, takže do pole se nacpou jména funkcí a některá hvězdička je přežvýká na adresy a pak už je to úplně obyčejné GOTO, resp. jmp v assembleru a autor blogu s tím dělá machry. Odhadl jsem to špatně?
for (i = 0; i < N(array_pf); i++)Nedá se však použít u dynamicky alokovaného pole. Tenhle program bys také mohl napsat tak, že bys poslední prvek v poli ukazatelů na funkci nastavil na NULL.
int main() { char *strings[] = {"Hello", NULL, "World"}; void (*array_pf[])(char *, ...) = {f1, f2, f3, NULL}; print(array_pf, strings); return 0; } void print(void (*apf[])(char *, ...), char *s[]) { while (*apf) (*apf++)(*s++, "!!!\n", 42); }Mimochodem zvyšování strings nebo array_pf pomocí operátoru ++ ti nebude fungovat ve funkci main(), protože obě proměnné jsou deklarovány jako pole ukazatelů a na pole nelze používat operátory ++ nebo --. Můžeš si však pomoci funkcí, která ve skutečnosti převede pole ukazatelů na ukazatel na ukazatele. C není moc snadný jazyk.
Můžeš si však pomoci funkcí, která ve skutečnosti převede pole ukazatelů na ukazatel na ukazatele.Na to nepotřebuješ funkci, stačí přetypovat. Minimalistický příklad:
#include <stdio.h>
int main(int argc, char **argv) {
int pole[] = {1, 2, 3, 0};
for (int *ptr = pole; *ptr; ptr++) printf("%d\n", *ptr);
return 0;
}
Ten výraz v závorkách za tim vypočítává nějakou velikost, kterou pak přiřadí do tý konstanty, nebo co? Sizeof je, myslím, získání délky/velikosti, takže zjistí velikost "a" a podělí ji čím, polem a?No, ona se ta velikost vlastně nepočítá, ale určí už během překladu, v přeloženém kódu je už jenom konstantní hodnota (proto to nejde použít na dynamická pole). Operátor
sizeof
vrací velikost, ale v bytech, takže pokud je pole z čehokoliv jiného, tak se musí podělit velikostí prvku. V praxi se to dělá spíš naopak, počet prvků je většinou známý předem a velikost se získává vynásobením velikostí prvku, např. stylem dynamicke_pole=ḿalloc(pocet_prvku*sizeof(typ_prvku))
....
… nechce se mi hned instalovat a babrat se s nějakým IDE, možná později.Celý Unix je IDE. Nainstaluj build-essential (metabalíček s gcc, make, libc-dev) a pak už potřebuješ jen textový editor.
Trochu se mi zamotala hlava, tak jsem si cvaknul něčeho ostřejšího (naštěstí máme domácí pálenku... ). Uvádí tam takový návod, že je dobrý číst to od prostředka.Tak, případně můžeš použít cdecl ...