abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×
    dnes 17:33 | Nová verze

    Byla vydána nová stabilní verze 7.6 webového prohlížeče Vivaldi (Wikipedie). Postavena je na Chromiu 140. Přehled novinek i s náhledy v příspěvku na blogu.

    Ladislav Hagara | Komentářů: 0
    dnes 16:22 | Nová verze

    Byla vydána verze 1.90.0 programovacího jazyka Rust (Wikipedie). Podrobnosti v poznámkách k vydání. Vyzkoušet Rust lze například na stránce Rust by Example.

    Ladislav Hagara | Komentářů: 0
    dnes 16:11 | Nová verze

    GNUnet (Wikipedie) byl vydán v nové major verzi 0.25.0. Jedná se o framework pro decentralizované peer-to-peer síťování, na kterém je postavena řada aplikací.

    Ladislav Hagara | Komentářů: 0
    dnes 12:11 | Nová verze

    Byla vydána nová major verze 7.0 živé linuxové distribuce Tails (The Amnesic Incognito Live System), jež klade důraz na ochranu soukromí uživatelů a anonymitu. Nově je postavena je na Debianu 13 (Trixie) a GNOME 48 (Bengaluru). Další novinky v příslušném seznamu.

    Ladislav Hagara | Komentářů: 0
    dnes 04:44 | IT novinky

    Společnost Meta na dvoudenní konferenci Meta Connect 2025 představuje své novinky. První den byly představeny nové AI brýle: Ray-Ban Meta (Gen 2), sportovní Oakley Meta Vanguard a především Meta Ray-Ban Display s integrovaným displejem a EMG náramkem pro ovládání.

    Ladislav Hagara | Komentářů: 0
    dnes 01:11 | Nová verze

    Po půl roce vývoje od vydání verze 48 bylo vydáno GNOME 49 s kódovým názvem Brescia (Mastodon). S přehrávačem videí Showtime místo Totemu a prohlížečem dokumentů Papers místo Evince. Podrobný přehled novinek i s náhledy v poznámkách k vydání a v novinkách pro vývojáře.

    Ladislav Hagara | Komentářů: 11
    včera 16:22 | Nová verze

    Open source softwarový stack ROCm (Wikipedie) pro vývoj AI a HPC na GPU od AMD byl vydán ve verzi 7.0.0. Přidána byla podpora AMD Instinct MI355X a MI350X.

    Ladislav Hagara | Komentářů: 0
    včera 15:22 | Nová verze

    Byla vydána nová verze 258 správce systému a služeb systemd (GitHub).

    Ladislav Hagara | Komentářů: 6
    včera 15:11 | Nová verze

    Byla vydána Java 25 / JDK 25. Nových vlastností (JEP - JDK Enhancement Proposal) je 18. Jedná se o LTS verzi.

    Ladislav Hagara | Komentářů: 0
    včera 14:44 | Humor

    Věra Pohlová před 26 lety: „Tyhle aféry každého jenom otravují. Já bych všechny ty internety a počítače zakázala“. Jde o odpověď na anketní otázku deníku Metro vydaného 17. září 1999 na téma zneužití údajů o sporožirových účtech klientů České spořitelny.

    Ladislav Hagara | Komentářů: 9
    Jaké řešení používáte k vývoji / práci?
     (41%)
     (56%)
     (3%)
     (9%)
     (13%)
     (6%)
     (13%)
     (6%)
     (16%)
    Celkem 32 hlasů
     Komentářů: 4, poslední dnes 19:18
    Rozcestník

    Administrace komentářů

    Jste na stránce určené pro řešení chyb a problémů týkajících se diskusí a komentářů. Můžete zde našim administrátorům reportovat špatně zařazenou či duplicitní diskusi, vulgární či osočující příspěvek a podobně. Děkujeme vám za vaši pomoc, více očí více vidí, společně můžeme udržet vysokou kvalitu AbcLinuxu.cz.

    Příspěvek
    25.2.2020 19:45 Andrej | skóre: 51 | blog: Republic of Mordor
    Rozbalit Rozbalit vše Re: Změna typu existujících integerů v poli
    Dá se to nějak provést bez tvorby ještě jednoho pole uint16_t o stejné velikosti?

    Ano. Například nějak tahle (convert_in_place(...)):

    #include <errno.h>
    #include <fcntl.h>
    #include <stdint.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <unistd.h>
    
    static const size_t SIZE = 100000;
    typedef uint16_t narrow_array_t[SIZE];
    typedef uint32_t wide_array_t[SIZE];
    typedef uint16_t (*narrow_array_ptr)[SIZE];
    typedef uint32_t (*wide_array_ptr)[SIZE];
    
    ////////////////////////////////////////////////////////////////////////////////
    static narrow_array_ptr convert_in_place(const wide_array_ptr wide_array) {
      const uint32_t *source = *wide_array;
      uint16_t *dest = (uint16_t*)source;
      const uint16_t *const end = dest + SIZE;
      while (dest < end) *dest++ = *source++;
      return realloc(wide_array, sizeof(narrow_array_t));  // free extra memory
      // return (narrow_array_ptr)wide_array;              // keep extra memory
    }
    ////////////////////////////////////////////////////////////////////////////////
    
    static int dump_array_to_file(const char *const file_name,
                                  const narrow_array_ptr narrow_array) {
      const int output = open(file_name,
                              O_WRONLY | O_CREAT | O_TRUNC,
                              S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
      if (output == -1) {
        fputs(strerror(errno), stderr);
        return EXIT_FAILURE;
      }
      int result = EXIT_SUCCESS;
      size_t to_write = sizeof(narrow_array_t);
      uint8_t *buffer = (uint8_t*)narrow_array;
      while (to_write) {
        const ssize_t written = write(output, buffer, to_write);
        if (written == -1) {
          result = EXIT_FAILURE;
          fputs(strerror(errno), stderr);
          break;
        }
        buffer += written;
        to_write -= written;
      }
      if (close(output) == -1) {
        fputs(strerror(errno), stderr);
        return EXIT_FAILURE;
      }
      return result;
    }
    
    int main() {
      // Allocate and populate an array of 32-bit integers.
      uint32_t (*const wide_array)[SIZE] = malloc(sizeof(wide_array_t));
      if (!wide_array) {
        fputs(strerror(errno), stderr);
        return EXIT_FAILURE;
      }
      for (size_t i = 0; i < SIZE; ++i) (*wide_array)[i] = i % 16384;
    
      // Compact 32-bit integers into 16-bit integers in-place.
      uint16_t (*const narrow_array)[SIZE] = convert_in_place(wide_array);
      
      // Write compacted array to standard output, just for fun.
      const uint16_t *const end = *narrow_array + SIZE;
      for (uint16_t *number = *narrow_array; number < end; ++number)
        printf("%d, ", *number);  // unchecked!
      putchar('\n');              // unchecked!
    
      // Write the compacted array into a binary file.
      int result = dump_array_to_file("/tmp/output", narrow_array);
      
      free(narrow_array);
      return result;
    }
    

    Pokud se nepletu, tento^^^ kód nezávisí na endianness, protože nedělá žádné podivné bitové operace. Tedy na BE vyrobí binární soubor v BE, na LE vyrobí binární soubor v LE. (A pokud se pletu, hned se mi bude někdo posmívat, takže dobře mi tak.)

    Nebo přesvědčit fwrite, aby ukládal jen posledních 16bitů z každého prvku a to ostatní ignoroval (tedy ani nevyplňoval nulama).

    Ano, tohle by taky šlo, ale musel by se ten fwrite() (nebo write()) volat SIZE-krát, vždycky na ty 2 byty, což by bylo celkem ošklivé a navíc by to bylo závislé na endianness, tj. muselo by se podle LE/BE správně určit, které 2 byty vypsat.

    V tomto formuláři můžete formulovat svou stížnost ohledně příspěvku. Nejprve vyberte typ akce, kterou navrhujete provést s diskusí či příspěvkem. Potom do textového pole napište důvody, proč by měli admini provést vaši žádost, problém nemusí být patrný na první pohled. Odkaz na příspěvek bude přidán automaticky.

    Vaše jméno
    Váš email
    Typ požadavku
    Slovní popis
    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.