Crunchez vos adresses URL
|
Rejoignez notre discord
|
Hébergez vos photos
Page 86 sur 86 PremièrePremière ... 3676787980818283848586
Affichage des résultats 2 551 à 2 580 sur 2580
  1. #2551
    Bon... je ne peux plus suivre ce topic.
    Avast me signale 2 virus à chaque fois que je viens ici.

    Je pense que c'est la signature d'un posteur.

    Après, virus réel ou faux positif...
    Baalimologue - Le topic du The Voice of the X-Factor Canard's Got Talent & autres Vocalises.
    Battle.net (Diablo 3) : Fbzn#2658 ----- / ----- / ----- Steam ID

  2. #2552
    Tu peux choisir de masquer les signatures ;-)

  3. #2553
    Citation Envoyé par war-p Voir le message
    Ah ouais, je vois qui c'est... Le mec fait du go

    Sinon, j'irai certainement au meetup sur rust le 4 octobre, il y aura Steeve klabnik.
    Inscrit!
    J'étais pas sûr de pouvoir viendre, mais en fait si.

  4. #2554
    J'ai une petite question. J'ai encore l'impression d'inventer la std::roue en C++17...

    Je veux pouvoir faire ce truc tout con:

    auto [x, y, z] = mymeta::splitArray3(m_volume -> GetDimensions());
    pour déclarer x, y, z en variables int qui vont récupérer la taille du volume, qui nous est tout le temps retournée comme un tableau de 3 ints.
    On a également des tailles de pixels en double*, etc: vive VTK.

    J'ai donc fait çà, tout bêtement:

    template <typename T>
    std::tuple<T, T, T>
    splitArray3(T* array)
    {
    MSG_ASSERT(array != nullptr , "null array to split");
    return std::make_tuple(array[0], array[1], array[2]);
    }
    Avant de partir sur une éventuelle version variadique qui s'annoncerait prise de tête (genre pour gérer (x,y) sur une image voire (r,g,b,a), etc), je me demande si j'ai pas simplement raté un mécanisme déjà prévu pour quelque chose qui semble bateau à mort

  5. #2555
    Depuis un pointeur, je suis pas très inspiré. J'ai pensé à std::span (c++20 donc pas une bonne réponse de toute façon), mais en fait on ne peut pas en construire de taille fixe à partir d'un pointeur.

    La question que je me pose maintenant c'est : en pratique, qu'est ce qui peut arriver de mal avec un reinterpret_cast<T(&)[N]>(array) ?

    GCC n'est pas fan :
    Code:
    warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
        9 |     auto [x, y, z] = reinterpret_cast<int(&)[3]>(array_ptr);
          |                                                  ^~~~~~~~~
    Edit: apparemment, c'est parce que le cast correct est reinterpret_cast<T(&)[N]>(*array), ou "ce qui pointé par array est un tableau de N Ts", ce qui est plus logique en fait, alors que j'essayais de faire un array-to-pointer à l'envers.
    Dernière modification par Cwningen ; 01/10/2019 à 01h47.

  6. #2556
    Citation Envoyé par vectra Voir le message
    Inscrit!
    J'étais pas sûr de pouvoir viendre, mais en fait si.
    Si je me suis pas viandé dans l'inscription, j'y serai en principe.

  7. #2557
    Cool

    Si tu vois un vieux au milieu des jeunes qui dit que Lisp c'était mieux, cherche pas qui c'est...

  8. #2558
    Je viens en moto ( donc blouson cuir) avec un sweat rouge si jamais

  9. #2559
    Chemise blanche en ce qui me concerne...
    On est presque à côté en fait

  10. #2560
    Oï les gens

    Bon, j'ai mon client qui a besoin d'un renfort ASAP, pour une durée de 2 a 3 mois. Il est donc près a mettre le pognon pour prendre un freelance supplémentaire pour cette période. Alors ouais, je sais c'est court, mais bon, ça reste une petite start up, avec le gros avantage que le dev se fera en télétravail.

    C'est une application REST écrite en Java/Kotlin. L'objectif étant a terme de faire disparaitre le Java, le dev se fera en Kotlin. Elle est basé sur une stack classique Spring Boot/Hibernate/Postgresql, avec Gradle en système de build. La boite est située sur Marseille, mais on cherche un freelance sur Lyon, Grenoble ou Valence. En effet, le dev se fera en télétravail, mais l'objectif est de pouvoir se voir en face a face au moins une (idéalement deux) fois par semaine, et ce sont les trois villes qui sont le plus accessible pour ma pomme

    Au niveau des connaissance avec expérience indispensables :
    - Java
    - Spring (MVC et Rest)
    - Hibernate
    - Git
    - REST

    - Connaissance gros plus (pas forcément besoin d'XP dessus, mais au moins avoir lu la doc et fait un ou deux exos/tutorial):
    - Kotlin
    - Spring Boot
    - Spring Data
    - Flyway
    - Gradle

    Docn voila, si vous pensez être intéressé, ou que vous connaissez quelqu'un qui pourrait l'être, ma boite a PM est ouverte.

    EDIT : J'ai oublié de le préciser, mais on cherche quelqu'un d'un minimum experimenté. 5 ans mini, je dirais, mais ça reste ouvert a discussion. Ce qui est clair, c'est qu'on ne peut pas prendre quelqu'un dont ça serait la première expérience professionnelle
    Dernière modification par Teocali ; 07/10/2019 à 12h08.
    Ce qu'il faut savoir, c'est qu'on ment beaucoup aux minmatars, surtout lorsqu'ils posent des questions du style: "t'es sûr que ça vole, ce truc ?" Cooking Momo, le 30/08/09

  11. #2561

  12. #2562

  13. #2563
    Je crois qu'on en avait déjà parlé, mais ça ne me dit plus rien.

    Je cherche un moyen propre de factoriser deux membres d'une classe qui ont cette forme:

    Code:
    void
    class::memberForward()
    {
     // long header
     <specific Forward part>
     // long footer
    }
    
    void
    class::memberBackward()
    {
     // long header
     <specific Backward part>
     // long footer
    }

  14. #2564
    Une fonction d'ordre supérieur ?
    Code:
    template <typename Function>
    void doSomething(Function f) {
        // long header
        f();
        // long footer
    }
    Ou du RAII (un objet qui fait "long header" dans son constructeur et "long footer" dans son destructeur) ?

  15. #2565
    Y'a plein de moyens de faire ça mais pas sûr d'avoir compris la factorisation que tu recherches. C++ ?

    Deux versions (la deuxième c'est ce que Cwningen propose, la première c'est juste header et footer factorisés dans leur propre fonction):

    Code:
    #include <functional>
    #include <iostream>
    
    static void longHeader() {
        std::cout << "long header" << std::endl;
    }
    static void longFooter() {
        std::cout << "long header" << std::endl;
    }
    
    class MyClass {
      public:
        static void memberForward();
        static void memberBackward();
    };
    
    void MyClass::memberForward() {
        longHeader();
        std::cout << "<specific Forward part>" << std::endl;
        longFooter();
    }
    
    void MyClass::memberBackward() {
        longHeader();
        std::cout << "<specific Backward part>" << std::endl;
        longFooter();
    }
    
    class WrappedCall {
      public:
        static void wrapMyCall(const std::function<void()>& injected) {
            longHeader();
            injected();
            longFooter();
        }
    };
    
    int main() {
        MyClass::memberForward();
        std::cout << std::endl;
    
        MyClass::memberBackward();
        std::cout << std::endl;
    
        WrappedCall::wrapMyCall([]{
            std::cout << "Hey" << std::endl;
        });
    }
    Sinon (3ème version) tu peux injecter une interface:

    Code:
    #include <functional>
    #include <iostream>
    #include <memory>
    
    static void longHeader() {
        std::cout << "long header" << std::endl;
    }
    static void longFooter() {
        std::cout << "long header" << std::endl;
    }
    
    class Interface {
      public:
        virtual void Do() = 0;
    };
    
    class Forward : public Interface {
      public:
        void Do() override {
            std::cout << "Forward" << std::endl;
        }
    };
    
    class Backward : public Interface {
      public:
        void Do() override {
            std::cout << "Backward" << std::endl;
        }
    };
    
    class WrappedCall {
      public:
        static void wrapMyCall(const std::shared_ptr<Interface>& interface) {
            longHeader();
            interface->Do();
            longFooter();
        }
    };
    
    int main() {
        auto forward = std::make_shared<Forward>();
        auto backward = std::make_shared<Backward>();
    
        WrappedCall::wrapMyCall(forward);
        std::cout << std::endl;
    
        WrappedCall::wrapMyCall(backward);
    }
    Dernière modification par Kamikaze ; 26/10/2019 à 13h09.

  16. #2566
    C'est moche les interfaces pour un rien façon Java. En C++, on fait mieux avec des pointeurs de fonctions, functors or lambdas.

    Aussi le pointeur partagé est inutile, et WrappedCall::wrapMyCall devrait prendre un (const?) Interface &. On ne passe une référence vers le pointeur partagé que si on veut le copier.

  17. #2567
    static void wrapMyCall(const std::shared_ptr<Interface>& interface)

    Je prends bien un const non?

    Si j'ai mis un shared ptr c'est simplement pour être très générique pour l'exemple, j'aurais pu utiliser un raw pointer ou n'importe quoi d'autre, référence, static polymorphism avec template, std::variant, etc. etc. Je peux pas savoir ce qu'il veut, la sémantique et l'idée reste la même quelque soit la mécanique d'injection utilisée

    - - - Mise à jour - - -

    Code:
    #include <functional>
    #include <iostream>
    #include <memory>
    
    static void longHeader() {
        std::cout << "long header" << std::endl;
    }
    static void longFooter() {
        std::cout << "long header" << std::endl;
    }
    
    class Interface {
      public:
        virtual void Do() const = 0;
    };
    
    class Forward : public Interface {
      public:
        void Do() const override {
            std::cout << "Forward" << std::endl;
        }
    };
    
    class Backward : public Interface {
      public:
        void Do() const override {
            std::cout << "Backward" << std::endl;
        }
    };
    
    class WrappedCall {
      public:
        static void wrapMyCall(const Interface& interface) {
            longHeader();
            interface.Do();
            longFooter();
        }
    };
    
    int main() {
        Forward forward;
        Backward backward;
    
        WrappedCall::wrapMyCall(forward);
        std::cout << std::endl;
    
        WrappedCall::wrapMyCall(backward);
    }

  18. #2568
    Citation Envoyé par Kamikaze Voir le message
    Si j'ai mis un shared ptr c'est simplement pour être très générique pour l'exemple, j'aurais pu utiliser un raw pointer ou n'importe quoi d'autre, référence, static polymorphism avec template, std::variant, etc. etc. Je peux pas savoir ce qu'il veut, la sémantique et l'idée reste la même quelque soit la mécanique d'injection utilisée
    Justement, la référence marche avec tout. Alors que si tu mets un shared_ptr dans l'interface (alors que tu ne t'en sers pas), tu forces l'utilisateur à en créer un.

    Le const, ce n'était pas contre toi, le point d'interrogation est là car dans certains cas où on pourrait vouloir des objets fonctions mutables (mais ce n'est pas très pratique si ce n'est pas un template).

  19. #2569
    Hmmm, le problème de la réference c'est que si l'objet référencé sort du scope, tu manipules désormais une référence vide. Chaque implémentation a son avantage. Je pense pas que y'ait d'équivalence stricte dans celles que j'ai mentionnées. En tout cas en C++

    Code:
    #include <functional>
    #include <iostream>
    #include <memory>
    #include <thread>
    
    static void longHeader() {
        std::cout << "long header" << std::endl;
    }
    static void longFooter() {
        std::cout << "long header" << std::endl;
    }
    
    class Interface {
      public:
        virtual void Do() const = 0;
    };
    
    class Forward : public Interface {
      public:
        void Do() const override {
            std::cout << data << std::endl;
        }
        ~Forward() {
            data = "Destroyed";
        }
      private:
        std::string data = "Forward";
    };
    
    class Backward : public Interface {
      public:
        void Do() const override {
            std::cout << "Backward" << std::endl;
        }
    };
    
    class WrappedCall {
      public:
        static void wrapMyCall(const Interface& interface) {
            longHeader();
            interface.Do();
            longFooter();
        }
    };
    
    int main() {
        using namespace std::chrono_literals;
    
        Backward backward;
    
        std::thread delayedCallforward;
        {
            Forward forward;
            delayedCallforward = std::thread([&] {
                std::this_thread::sleep_for(1s);
                WrappedCall::wrapMyCall(forward); // BIG TROUBLES AHEAD
                std::cout << std::endl;
            });
        }
    
        WrappedCall::wrapMyCall(backward);
        delayedCallforward.join();
    }
    - - - Mise à jour - - -

    Output

    Code:
    long header
    Backward
    long header
    long header
    Destroyed
    long header
    Un shared_ptr a "l'intelligence" de ne pas appeler le destructeur tant que l'objet est consommé par quelqu'un dans ce cas. S'pour ça que je le trouve "plus générique" en tant que réponse universelle a cette question assez vague/généraliste.

    Bien sûr un shared_ptr est plus couteux, sous-entend a priori/en général qu'on manipule des objets (données + méthodes, constructeur, destructeur), etc. etc.

  20. #2570
    Dans ce cas tu passes le shared_ptr par valeur. La référence vers le shared_ptr peut tout autant devenir invalide.

  21. #2571
    Ouais c'était un mauvais exemple de ma part pour ce point, mais bon on part un peu loin là. Je voulais surtout répondre que y'a pas vraiment d'équivalence stricte entre les 2. Mais sinon je suis d'accord, rien ne sert d'utiliser la sémantique de pointeurs si ce n'est pas nécessaire.

    Smart pointer hors du scope

    Code:
    #include <functional>
    #include <iostream>
    #include <memory>
    #include <thread>
    #include <utility>
    
    static void longHeader() {
        std::cout << "long header" << std::endl;
    }
    static void longFooter() {
        std::cout << "long footer" << std::endl;
    }
    
    class Interface {
      public:
        virtual void Do() const = 0;
    };
    
    class Forward : public Interface {
      public:
        void Do() const override {
            std::cout << data << std::endl;
        }
        ~Forward() {
            data = "Destroyed";
        }
      private:
        std::string data = "Forward";
    };
    
    class Backward : public Interface {
      public:
        void Do() const override {
            std::cout << "Backward" << std::endl;
        }
    };
    
    class WrappedCall {
      public:
        explicit WrappedCall(std::shared_ptr<Interface> interface) : interface(std::move(interface)) {
        }
    
        void wrapMyCall() {
            longHeader();
            interface->Do();
            longFooter();
        }
      private:
        std::shared_ptr<Interface> interface;
    };
    
    int main() {
        using namespace std::chrono_literals;
    
        std::unique_ptr<WrappedCall> wrapped_call;
        std::thread delayedCallforward;
        {
            auto forward = std::make_shared<Forward>();
            wrapped_call = std::make_unique<WrappedCall>(forward);
            delayedCallforward = std::thread([&] {
                std::this_thread::sleep_for(1s);
                wrapped_call->wrapMyCall();
                std::cout << std::endl;
            });
        }
        delayedCallforward.join();
    }
    Output

    Code:
    long header
    Forward
    long footer
    Référence hors du scope

    Code:
    #include <functional>
    #include <iostream>
    #include <memory>
    #include <thread>
    #include <utility>
    
    static void longHeader() {
        std::cout << "long header" << std::endl;
    }
    static void longFooter() {
        std::cout << "long footer" << std::endl;
    }
    
    class Interface {
      public:
        virtual void Do() const = 0;
    };
    
    class Forward : public Interface {
      public:
        void Do() const override {
            std::cout << data << std::endl;
        }
        ~Forward() {
            data = "Destroyed";
        }
      private:
        std::string data = "Forward";
    };
    
    class Backward : public Interface {
      public:
        void Do() const override {
            std::cout << "Backward" << std::endl;
        }
    };
    
    class WrappedCall {
      public:
        explicit WrappedCall(Interface& interface) : interface(interface) {
        }
    
        void wrapMyCall() {
            longHeader();
            interface.Do();
            longFooter();
        }
      private:
        Interface& interface;
    };
    
    int main() {
        using namespace std::chrono_literals;
    
        std::unique_ptr<WrappedCall> wrapped_call;
        std::thread delayedCallforward;
        {
            Forward forward;
            wrapped_call = std::make_unique<WrappedCall>(forward);
            delayedCallforward = std::thread([&] {
                std::this_thread::sleep_for(1s);
                wrapped_call->wrapMyCall(); // Erreur de la part du développeur? A priori sa responsabilité de ne pas utiliser un objet qui sort du scope
                std::cout << std::endl;
            });
        }
        delayedCallforward.join();
    }
    Output

    Code:
    long header
    Destroyed
    long footer
    Après clairement cet exemple me parait un peu trop forcé, en l'occurrence, et je dois bien dire que finalement en terme de choix "général" je pense que tu as raison et que la majorité du temps on n'utilisera un référence.

    https://github.com/isocpp/CppCoreGui...-smartptrparam
    https://github.com/isocpp/CppCoreGui...-is-part-owner
    https://github.com/isocpp/CppCoreGui...shared-pointer

  22. #2572
    Et une dernière courte référence qui mentionne explicitement ce cas

    https://docs.microsoft.com/en-us/vis...8?view=vs-2019

  23. #2573
    Code:
        {
            auto forward = std::make_shared<Forward>();
            wrapped_call = std::make_unique<WrappedCall>(forward);
            delayedCallforward = std::thread([&] {
                std::this_thread::sleep_for(1s);
                wrapped_call->wrapMyCall();
                std::cout << std::endl;
            });
        }
        delayedCallforward.join();
    On est d'accord que la référence wrapped_call n'est peut être plus valide quand le thread l'utilise ? Ah, non c'est déclaré plus tôt.

  24. #2574
    Microsoft ayant définitivement tiré un trait sur tout ce qui est embarqué (c'était à prévoir, vu que ça n'avait pas évolué depuis le .Net 3.5), va falloir que je passe sur Android/Kotlin très rapidement. Vous avez des bons bouquins/des bonnes ressources là-dessus ?

    Quelqu'un a testé les cours de Pluralsight dessus ? En .Net, ils étaient top, mais aucune idée de ce qu'ils valent pour cette techno.

  25. #2575
    Comme souvent de nos jours, la doc officielle est très bien, avec un playground, la description d'idiomes, etc.

    Il y a "Kotlin in action", écrit par des gens de Jetbrains qui est pas mal même si un peu verbeux.

    Et abonne toi à la newsletter Kotlin weekly, quelques articles intéressants chaque semaine:
    http://www.kotlinweekly.net/

  26. #2576
    Citation Envoyé par Kamikaze Voir le message
    Et une dernière courte référence qui mentionne explicitement ce cas

    https://docs.microsoft.com/en-us/vis...8?view=vs-2019
    Citation Envoyé par Cwningen Voir le message
    On est d'accord que la référence wrapped_call n'est peut être plus valide quand le thread l'utilise ? Ah, non c'est déclaré plus tôt.
    Merci pour vos conseils, c'était très instructif

  27. #2577
    Udacity (https://www.udacity.com/courses/all?keyword=kotlin) propose des cours gratuits (les payants sont à plus de 1000e mais très complets avec la possibilité de faire un portfolio sympathique).

  28. #2578
    Citation Envoyé par TwinBis Voir le message
    Comme souvent de nos jours, la doc officielle est très bien, avec un playground, la description d'idiomes, etc.

    Il y a "Kotlin in action", écrit par des gens de Jetbrains qui est pas mal même si un peu verbeux.

    Et abonne toi à la newsletter Kotlin weekly, quelques articles intéressants chaque semaine:
    http://www.kotlinweekly.net/
    Je vais regarder ça, merci

    Citation Envoyé par Nilct Voir le message
    Udacity (https://www.udacity.com/courses/all?keyword=kotlin) propose des cours gratuits (les payants sont à plus de 1000e mais très complets avec la possibilité de faire un portfolio sympathique).
    Ça a l'air pas mal, mais quand ils disent 2 mois pour se former, c'est trop long pour moi

  29. #2579
    Tu peux le faire en un WE, c'est à ton rythme. Et tu as accès à tout le programme.

    Quand c'est payant, c'est beaucoup de travail et donc de temps nécessaire... mais tu as l'avantage de faire des projets et d'avoir un mentor qui évalue tes productions.

  30. #2580
    On m'a envoyé une offre de job CUDA en Bretagne via une SSII je pense.
    Si ça intéresse des gens, me contacter. Y'a peu de profils dispo on dirait...

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •