C/C++

Adhattam volna címnek azt is hogy „újszülöttnek minden vicc új”, vagy hogy „ma is tanultam valamit”...

A lényeg ez a titokzatos sor (én írtam):

//tokencopy(f,g,g+1);
f->T[g]=f->T[g+1];

Mármint, ugye nem 1 hanem 2 sor. Ezek egy általam írt programban vagynak benne (a legújabb programnyelvemről van szó de tökmindegy). Előbb azt a sort tettem csak bele ami itt ki van kommentezve. Ez ugye egy (globális)függvény, ami annyit csinál, hogy egy struktúrákat tartalmazó tömb 2 elemét átmásolja, a g+1 -ediket a g-edik elembe, annak régi tartalmát felülírva. (Az "f" is egy struktúra amúgy, de most nem arról van szó, hanem a T tömbről aminek az elemei struktúrák maguk is). Persze senki ne gondoljon olyan böszmeségre, hogy a struktúra minden mezőjét külön másolom, csináltam 2 pointert mindegyik struktúra kezdetére mutatva, majd castoltam őket unsigned long long * típusúra, aztán egy ciklussal át lett másolva minden unsigned long long érték, a ciklus addig ment amennyi a struktúrám sizeof() értéke... Így jó lesz akkor is ha a struktúra mérete megváltozik. Arra kell csak ügyelnem, a mérete mindig az unsigned long long méretének többszöröse legyen.

Na de ez majdnem mellékes volt. A lényeg tehát hogy ezt a függvényt megírtam, amikor jött egy fura ötletem. Az, amiért kikommenteztem a tokencopy sort ami meghívná a függvényemet s leírtam helyette az alatta levő sort. Mert hátha van már olyan okos a C nyelv hogy képes ő maga is struktúrákat másolni... Tudtam ugyan, az eredeti Kernighan/Ritchie könyv szerint struktúrák esetén az egyetlen művelet a pointerük képzése, de a C++ esetén már rég úgy van (amennyire tudom legalábbis) hogy képes a struktúrák másolására. Gondoltam, hátha ezt az okosságot átemelték már a C nyelvbe is azóta!

És voila, behold meg hasonlók - simán lefordult a programom így is, még csak nem is warningolt!

Lehet hogy most megkapom a trolloktól a kiosztást hogy ez ilyen meg olyan ősrégi feature már, miért is nem tudtam róla korábban... Hja, kérem, nekem senki nem oktatta a progranyozást főiskolán, magam tanultam, És az eredeti Kernighan könyvből. Az, hm, talán mégse a legújabb verziója a C nyelvnek... Szóval, ezt most fedeztem fel és kész... De örülök neki! Nagyon jó kis feature.

Jó pap holtig tanul ugye. Sőt még az is aki nem pap.

STM8S -re írok egy egyszerű polling -os i2c handlert.
Több helyen szükség van arra, hogy kiolvassak egy-egy státusz regisztert, így lehet tovább lépni. A beolvasott értékkel nem érdekel, nem kell vele műveleteket végeznem, de ki kell olvasnom, különben nem lehet tovább lépni.

Az egyik forrásban pl. így oldotta meg a szerző "(void) I2C_SR3;" - no ezt a mostani SDCC simán ki optimalizálja, hiszen semmire nincs használva.
Egyelőre úgy "kerültem meg" hogy foglaltam egy fájl globál változót és abba "olvasom bele" a regiszter értékét. (Később, lehet még jó valamire, mondjuk hiba kezelésre, de most semmi szükségem rá, csak foglalja az értékes memóriát.)

Tudtok valami más megoldást?

OFF: A terv az, hogy majd interrupt -ba kerül az egész, valószínűleg assembly -ben. De itt inkább az elv lenne a lényeg.

Sziasztok!

 Szükségem lenne a Lotus C++ API Toolkit for Notes/Domino 3.0i Multiplatform eAssembly nevű szoftverre. Ezt korábban bárki letölthette az IBM oldaláról, de onnan eltávolították, mert eladták egy HCL nevű indiai cégnek Lotus/Domino termékvonalat, a HCL viszont nem publikálja. Van itt esetleg valaki, aki elraktározta ezt magának korábban, és meg tudná osztani velem?

Előre is köszönöm.

Sziasztok!
Igazából arra lennék kíváncsi, hogy én rontok-e el valamit, vagy hiba van a libc-ben?

Van a következő forráskód: (a formaság kedvéért: src/tes2.c)
(egy nagyobb projekt része, azért van ennyi #include benne, ez egy kiragadott részlet, de egészben is ugyanezt produkálja)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h> 
#include <sys/types.h>
#include <sys/ipc.h>  
#include <sys/stat.h> 
#include <fcntl.h>  
#include <linux/limits.h>  
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define test_c 

int main(int argc, char *argv[]){
    char *buff1=NULL, *buff2=NULL, *buff3=NULL;    
    struct addrinfo hints;
    struct addrinfo *res;
    int err;

    memset(&hints, 0, sizeof(hints));   
    hints.ai_family = AF_UNSPEC;        
    hints.ai_socktype = SOCK_STREAM;    
  
    if((err = getaddrinfo("localhost", "http", &hints, &res)) != 0){
        printf( "getaddrinfo hiba: %s\n", gai_strerror(err));
        return -1;
    } 
    printf("1: %p, 2: %p, 3: %p", buff1, buff1, buff3);
    buff1 = malloc(100); /*<-- ezen sor hiányában is hibára fut */
    free(buff1);    /*<-- Ha ezt a free-t kikommentezem, akkor tökéletesen fut */

    printf("\n");
    return 0;
}

ezekkel a kapcsolókkal fordítom:

(természetesen itt is, a crypto libre szükség van a projektben, szóval nem hanyagságból van ott)

gcc -Wall -c -ggdb -Wpedantic -Wmissing-prototypes -o build/test2.o src/test2.c
gcc  build/test2.o -o bin/test2 -lefence -lcrypto

Ám a futtatáskor már ezt a hibaüzenetet kapom:
 

tux@pc:~$ ./bin/server
  Electric Fence 2.2 Copyright (C) 1987-1999 Bruce Perens <bruce@perens.com>
server: resolv_conf.c:423: __resolv_conf_allocate: Assertion `conf == ptr' failed.
Félbeszakítva (core készült)


tux@pc:~$ gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/7/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 7.5.0-3ubuntu1~18.04' --with-bugurl=file:///usr/share/doc/gcc-7/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-7 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04) 

Ahogy írtam a kódban, a megjelölt sorban, ha kommentbe teszem a free(buff1);-et, akkor minden tökéletesen működik.

Szóval mi lehet a nyűgje a getaddrinfo() -nak?

UPDATE:

Hogy másoknak kevesebb bosszúságot okozzon:

EF_ALIGNMENT=8 ./bin/test2

(és akkor pontos lesz az illesztés)

Részletek a linken. Csak hogy a KV-nál szakmaibb témákról is lehessen eszmét cserélni :D

https://medium.com/@mujjingun_23509/full-proof-that-c-grammar-is-undecidable-34e22dd8b664

Sziasztok!

Van egy távoli linuxos gép, amin ssh-n keresztül fejlesztek C/C++-ban.
No meg persze debuggolok gdb-vel.
Lokális Win10-en Eclipseben szeretném a debug felületet nézegetni, léptetni és a kimenetet nézegetni.

Szinte biztos vagyok benne, hogy összehozható, de még nem sikerült.
Kellene egy jó útbaigazító leírás.

R

A cím talán kissé érthetetlen de féltem nem férne bele a limitbe ha alaposan kimagyarázom ott...

Tehát, a bajom az hogy én szinte mindig C nyelven programozom, és úgy szeretném beállítani a gcc illetve g++ progit (nekem aztán teljesen mindegy hogy parancssori kapcsolóval vagy makefile által vagy bárhogy, csak legyen rá mód!) hogy ilyesmiket ne lehessen csinálni:

for(i=0;i<max;i++) a[i]=b[i];

Hanem csak ezt:

for(i=0;i<max;i++) {a[i]=b[i];}

azaz KÖVETELJE MEG a kapcsos zárójelek kitételét EGYETLEN utasítás esetén is!

Ugyanez igaz az if esetére is: ilyet NE lehessen:

if(a>b) g++;

Hanem csak így:

if(a>b) {g++;}

Tehát mindig, MINDIG követelje ki a kapcsos zárójeleket ilyenkor, egyetlen utasítás esetén is! És ne is warningoljon, hanem ha nincs ott, akkor simán ERROR és kész. Ne legyen hajlandó lefordítani. Léccike segítsetek! Ez az egyik legbosszantóbb hibája a C nyelvnek, hogy ilyesmiket megenged. Teljesen áttekinthetetlenné tudja tenni a kódot. Számtalan hibalehetőség forrása. Bevallom, semmiféle lehetőséget nem találtam ennek beállítására, pedig sokat keresgéltem.

Ez egy C++ specifikus "Én csináltam!" téma, egyben felhívás egy próba körre.

Forráskód: https://github.com/Morgan-Stanley/binlog
Dokumentáció: http://binlog.org/

Röviden: egy C++14 naplózó könyvtár, ami bináris logot gyárt: ezért nagyon gyors, a kimenet feldolgozása pedig könnyen gépesíthető. A bináris napló emberi fogyasztásra a mellékelt segédprogrammal (bread) alkalmas.

Vegyétek és fordítsátok, hátha valaki tudja jóra használni.

Írtam egy pluginbetöltő függvényt (a programnyelvemhez amúgy. Ez mellékes csak nem bírom megállni a dicsekvést). A függvény REMEKÜL MŰKÖDIK, ezt kihangsúlyozom, szóval nincs semmi hiba!

A bajom az amit bele is írtam a kódba megjegyzésként, hogy ha a kód úgy néz ki amint az a kikommentezett sorban vagyon, tehát ha közvetlenül castolom a pointert (ahogyan azt szerintem minden jótét és normális lélek ösztönösen csinálja, mintegy „csuklóból” mert az a logikus) akkor a g++ warningol mint az állat. (De a lefordított kód JÓ AKKOR IS!). A gcc viszont nem is warningol.

A warning üzenet ez:

loadplugin.cpp:72:49: error: ISO C++ forbids casting between pointer-to-function and pointer-to-object [-Werror]
nameptr=(upuplugin *)dlsym(Library,pluginname);
 

Maga a programrészlet (mindent kihagytam ami nem releváns. Hogy miféle union az az union upuu az se releváns):

#define usac   uint8_t

typedef void upuplugin(union upuu *th);

char *DLERRORstring=NULL; usac DLERRORflag=0;

void * loadplugin(void *Library, char *pluginname) {
DLERRORstring=NULL; DLERRORflag=0;
upuplugin *nameptr; nameptr=NULL;
if(Library   ==NULL)   {DLERRORflag=1; return nameptr;}
if(pluginname==NULL)   {DLERRORflag=2; return nameptr;}
if(pluginname[0]==0)   {DLERRORflag=3; return nameptr;}
dlerror(); // clear errorcode
// Ez lenne a logikus hívás, de valami ISO szabály miatt ekkor warningot dob a g++: (a gcc viszont NEM!):
//nameptr=(upuplugin *)dlsym(Library,pluginname);
*(void **)(&nameptr)=dlsym(Library,pluginname); // Ha így hívom meg a fenti helyett, nem dob warningot
DLERRORstring=dlerror();
if(DLERRORstring!=NULL) {DLERRORflag=4;nameptr=NULL;}
dlerror(); // clear errorcode
return (void *)nameptr;
}

Szóval nem értem, mi a rákért kell warningolnia egyrészt (ismétlem a kód JÓ és remekül működik!); másrészt ha ez a warningolás mégis szükséges valami komoly ok miatt, miért csak a g++ zaklat vele, a gcc miért nem.

Hello,

van egy ilyen kód (kipucolva, leegyszerüsítve, hátha valakit tényleg érdekel :))

#include <iostream>
#include <maxminddb.h>

class MyClass {
    public:
        bool lookup(const std::string& name);

    private:
        MMDB_s mmdb;
};

bool MyClass::lookup(const std::string& target) {

    int gai_error, mmdb_error;
    MMDB_lookup_result_s r;

    r = MMDB_lookup_string(&mmdb, target.c_str(), &gai_error, &mmdb_error);
    return true;
}

int main() {
    MyClass *c;

    c = new MyClass();
    std::string s = "foo";
    c->lookup(s);

    return 0;
}

Ez ezzel a paranccsal le is fordul:

g++ prog.cc -lmaxminddb

(clang-al is).

Ha a lookup() fv-t const-ra módosítom, akkor a fordító (mindegyik) elkezd rinyálni, de az MMDB_lookup_string()-re:

        bool lookup(const std::string& name) const;

...

bool MyClass::lookup(const std::string& target) const {

prog.cc: In member function 'bool MyClass::lookup(const string&) const':
prog.cc:17:28: error: invalid conversion from 'const MMDB_s*' to 'MMDB_s*' [-fpermissive]
   17 |     r = MMDB_lookup_string(&mmdb, target.c_str(), &gai_error, &mmdb_error);
      |                            ^~~~~
      |                            |
      |                            const MMDB_s*
In file included from constcheck.cc:2:
/usr/include/x86_64-linux-gnu/maxminddb.h:204:66: note:   initializing argument 1 of 'MMDB_lookup_result_s MMDB_lookup_string(MMDB_s*, const char*, int*, int*)'
  204 |     extern MMDB_lookup_result_s MMDB_lookup_string(MMDB_s *const mmdb,
      |                                                    ~~~~~~~~~~~~~~^~~~

Tud segíteni valaki ennek megértésében? Miért a fv törzsön belül egy másik fv argumentumánál panaszkodik, és miért csak akkor, ha ha fv const? Ennélkül miért fogadja el?