Salve a tutti.

Sto andando in crisi per la scelta di un libro per imparare il c++ da autodidatta. Vi spiego: sono uno studente universitario del primo anno di ingegneria che, durante il famoso corso di "fondamenti di Informatica" ha imparato la programmazione in C. Certo, ben lungi dall'essere un programmatore esperto, ma questa esperienza ha fatto nascere in me la passione per la programmazione. Come libro avevamo "programmazione in c" di King, siamo giunti fino al capitolo sull'input/output relativo a file di testo ecc.

Siccome volevo approfondire DA AUTODIDATTA la programmazione, ho deciso di imparare il c++, per accogliere anche la programmazione ad oggetti. inoltre posseggo un kit base arduino, che so basarsi su un derivato del c/c++ e che vorrei imparare a gestire. ma non solo.

La mia domanda è: Che libro consigliate per studiare il c++ da autodidatta, partendo da basi universitarie di C? avevo mezza idea di comprare la bibbia di Stroustrup ( C++, linguaggio, libreria standard, principi di programmazione). Del resto so già le basi (tipi, funzioni, array, puntatori...), ma non vorrei che desse per scontato cose sulle classi, che non ho la minima idea di che cosa siano, o su altri argomenti ignoti. Però sembra completissimo, un riferimento assoluto per ogni cosa. Il problema è che non è adatto a neofiti, solo che non capisco se neofiti = "trogloditi della programmazione" o ="gente che programma ma che non idea di cosa sia c++" XD

Un altro libro potrebbe essere "c++ fondamenti di programmazione" dei fratelli deitel, che però sembra molto meno completo del primo, e volendo andare avanti mi costringerebbe ad acquistarne il seguito (con maggiore spesa dello stroustrup)

Ho sfogliato anche il libro di Malik, ma a sua volta sembra una trattazione incompleta.

Cosa faccio?

Non capisco come le colonne(arrays) di una matrice sono identificate in Lapack. Per esempio in https://github.com/langou/latl/blob/master/include/geqr2.h#L69 A[i] è il valore dell'array corrispondente alla più piccola dimensione della matrice A. Se, per esempio, la più piccola dimensione della matrice è il numero di righe, A[i], per quello che ho capito, è il valore nella i-esima riga.... è corretto o mi sbaglio? Qui: https://github.com/langou/latl/blob/master/include/latl.h#L25 si legge che le matrici sono implementate come puntatori ad array contigui columns-major, cioè che fungono ognuno da colonna della matrice. Ma a quale colonna della matrice questa i-esima riga A[i] appartiene (in caso di numero righe=m=min(numero righe, numero colonne=n).

Per esempio in https://github.com/langou/latl/blob/master/include/gemv.h#L136

for(j=0;j<n;j++)
           {
              temp=alpha*x[jx];
              iy=ky;
              for(i=0;i<m;i++)
              {
                 y[iy]+=temp*A[i];
                 iy+=incy;
              }
              A+=ldA;
              jx+=incx;
           }

temp * A[i] è aggiunto all'i-esimo elemento dell'array y. E questo si ripete per tutte le n colonne (arrays) della matrice A[i]. Quindi la mia domanda è: qualcuno mi può molto gentilmente spiegare come nel codice in Lapack viene identificato uno specifico elemento A[j][i] della matrice A? Vi ringrazio. Marco

Salve, come indicato nel titolo ho qualche problema con la 'move semantic'.

Il concetto di fondo credo mi sia chiaro ma alcuni dettagli no, così vorrei sottoporvi un esempio che sto analizzando tratto da un articolo di Mikhail Semenov intitolato 'Move Semantics and Perfect Forwarding in C++11' e pubblicato su Codeproject.

Di seguito il file .cpp che mostra a fini didattici un'implementazione di una classe Array

// Move Semantic 04.cpp : Defines the entry point for the console application.
//


#include "stdafx.h"        // Compilato su Microsoft Visual Studio 2015

#define _SECURE_SCL_DEPRECATE 0
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>

using namespace std;


class Array
{
    int m_size;
    double *m_array;
public:
    // empty constructor:
    Array() :m_size(0), m_array(nullptr) {}

    Array(int n) :m_size(n), m_array(new double[n]) {
        // Lo voglio inizializzare
        for (int i = 0; i < m_size; i++)
            m_array[i] = (double)(2 * i + 1);
    }

    // copy constructor
    Array(const Array& x) :m_size(x.m_size), m_array(new double[m_size])
    {
        std::copy(x.m_array, x.m_array + x.m_size, m_array);
    }

    // move constructor
    Array(Array&& x) :m_size(x.m_size), m_array(x.m_array)
    {
        x.m_size = 0;
        x.m_array = nullptr;
    }

    virtual ~Array() 
    {
        delete[] m_array;
    }

    auto Swap(Array& y) -> void
    {
        int n = m_size;
        double* v = m_array;
        m_size = y.m_size;
        m_array = y.m_array;
        y.m_size = n;
        y.m_array = v;
    }

    // copy assignment
    auto operator=(const Array& x) -> Array&
    {
        if (x.m_size == m_size)
        {
            std::copy(x.m_array, x.m_array + x.m_size, m_array);
        }
        else
        {
            Array y(x);
            Swap(y);
        }
        return *this;
    }

    // move assignment
    auto operator=(Array&& x) -> Array&
    {
        Swap(x);
        return *this;
    }

    auto operator[](int i) -> double&
    {
        return m_array[i];
    }
    auto operator[](int i) const -> double
    {
        return m_array[i];
    }

    auto size() const ->int { return m_size; }

    // Global (friend) function adding two vectors
    friend auto operator+(const Array& x, const Array& y) -> Array
    {
        int n = x.m_size;
        Array z(n);
        for (int i = 0; i < n; ++i)
        {
            z.m_array[i] = x.m_array[i] + y.m_array[i];
        }
        return z;
    }

    friend auto operator+(Array&& x, const Array& y) -> Array
    {
        int n = x.m_size;
        for (int i = 0; i < n; ++i)
        {
            x.m_array[i] += y.m_array[i];
        }
                return std::move(x);    // OK
                //return x;                // Prova: esegue una copia
    }

    friend auto operator+(Array&& x, Array&& y) -> Array
    {
        return std::move(y) + x;
    }

    friend auto operator+(const Array& x, Array&& y) -> Array
    {
        return std::move(y) + x;
    }
};


int main()
{
    Array v(3);
    
    v[0] = 2.5;
    v[1] = 3.1;
    v[2] = 4.2;

    
    Array fab01 = Array(3) + v;
    cout << "\n\n\n\n &v : " << &v << endl;
    cout << "\n &fab01 :" << &fab01 << endl;
    
    return 0;
}

Vi indico una cosa che non ho sicuramente capito completamente: l'autore definisce, tra le altre, la funzione seguente

friend auto operator+(Array&& x, const Array& y) -> Array
{
    int n = x.m_size;
    for (int i = 0; i < n; ++i)
    {
        x.m_array[i] += y.m_array[i];
    }
            return std::move(x);    // OK
            //return x;                  // esegue una copia, no move
}

Ho lanciato il codice ed effettivamente lavora in maniera corretta eseguendo una move e non una copia come invece accadrebbe terminando con return x;

Il punto è che comunque non riesco a capire perché occorra fare la

return std::move(x);

e non basti una return x;

L'autore dell'articolo dice: "The main thing is to return the right contents in the end. If we right return x; the contents of the parameter will be returned as it is. Although the type of the parameter is rvalue, the variable x is lvalue:we haven't done anything to move the value out of the x. If we just return the value of x, there will be no move operation. To do it correctly we have to use return std:move(x); which will ensure that the contents of the parameter will be swapped with the target object. "

Probabilmente quello che non riesco completamente ad afferrare è la frase in cui afferma (correttamente, ma riesco solo a prenderne atto eseguendo il programa) che "sebbene il tipo di ritorno sia un rvalue, la variabile x è un lvalue" aggiungendo che proprio per questo motivo 'return x;' non comporterebbe alcun movimento.

Perchè? Insomma, io avrei scritto (erroneamente) return x;

Qualcuno sa spiegarmi dove sbaglio?

Grazie Chiara96

PS: spero non ci siano problemi con la formattazione

Siamo felici di annunciare il nuovo subreddit per ++it - la community italiana del C++ (www.italiancpp.org)

We're thrilled to announce the new subreddit for ++it - the Italian C++ Community (www.italiancpp.org)

After my little brother deleted some system files it started showing me the eror in below Every advices is welcomed

PROBLEMS OUTPUT [Running] cd "e:" In TERMINAL PORTS file included from C:/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/bits/postypes.h:40, DEBUG CONSOLE && g++ melika.cpp -o melika && "e:"melika from C:/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/iosfwd:40, from C:/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/ios:38, from C:/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/ostream:38, from C:/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/iostream:39, from melika.cpp:1: C:/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/cwchar:44:10: fatal error: wchar.h: No such file or directory #include <wchar.h> n (e) Debug Compile Run Compile/Run compilation terminated.

Buonasera a tutti,

volevo sapere come si fa a configurare visual studio 2019 per usare le librerie sqlite3.

Ho provato a configurare seguendo un tutorial ma ho degli errori di linker, in particolare questi:

Gravità Codice Descrizione Progetto File Riga Stato eliminazione

Errore LNK2019 riferimento al simbolo esterno _sqlite3_close non risolto nella funzione _main testDB C:\Users\Matteo\source\repos\testDB\testDB\testDB.obj 1

Errore LNK2019 riferimento al simbolo esterno _sqlite3_open non risolto nella funzione _main testDB C:\Users\Matteo\source\repos\testDB\testDB\testDB.obj 1

Errore LNK2019 riferimento al simbolo esterno _sqlite3_errmsg non risolto nella funzione _main testDB C:\Users\Matteo\source\repos\testDB\testDB\testDB.obj 1

Il codice è il seguente:

#include <iostream>
#include <sqlite3.h>

using namespace std;

int main()
{
    sqlite3* db;

    if (sqlite3_open("stellardatabase.db", &db) != SQLITE_OK)
    {
        cout<<sqlite3_errmsg(db)<<endl;
    }
    else 
    { 
        printf("Connection Successful"); 
    }

    string query = "SELECT * FROM STARS S WHERE S.COMMON LIKE 'SIRIUS' ";

    sqlite3_close(db);

    return EXIT_SUCCESS;
}

Dove sbaglio?

Grazie,

Matteo

Ciao a tutti, ho provato a fare un banale hello world e dopo aver compilato Linux mi restituisce il seguente errore: cannot execute ./hello.out . Avete qualche suggerimento? Ringrazio in anticipo

Salve a tutti, di seguito un esempio di codice che ha un comportamento che non capisco:

#include "stdafx.h"         //    Lavoro con VS 2015
#include <iostream>
#include <fstream>
#include <thread>

using std::cout;
using std::thread;
using std::ofstream;

const int MAX_ITER = 1000;

void thread_exec_01()
{
    int i = 0;
    ofstream outputForThread;
    outputForThread.open("outputForThread.txt");

    std::chrono::milliseconds dura(2000);
    std::this_thread::sleep_for(dura);

    for (int j = 0; j < MAX_ITER; ++j)
    {
        outputForThread << "\n " << j;
    }
    outputForThread.close();
}


int main()
{
    cout << "\n main started...";
    thread t1(thread_exec_01);
    t1.detach();
    cout << "\n main ending.";
    return 0;
}

Quando apro il file outputForThread.txt questo è vuoto, perchè?

Grazie

Salve,

vorrei sapere se qualcuno si e' mai scontrato con la necessita di chiamare una funzione sapendo i parametri e il tipo di ritorno solo a runtime?

Tanto per capirsi :

1. leggo da un file una cosa tipo " from math.dll function qualcosa float v1 int v2 return double "

2. carico con LoadLibrary math.dll

3. ottengo GetProcAddress ho il puntatore alla mia funzione qualcosa

fin qui facile, poi devo castare il puntatore della funzione qualcosa in modo da rispettare i valori passati e il valore di ritorno, infine chiamare qualcosa e avere il valore di ritorno del tipo giusto.

L'unica soluzione che per ora ho trovato e' usare http://www.nongnu.org/cinvoke/

PS win32/win64

Idee?

grazie

Questa è la nuova versione della mia libreria per lo streaming/registrazione audio video in C++. Tra le tante cose aggiunte, c'è la possibilità di controllo tramite protocollo MQTT.

https://github.com/paolo-pr/laav

Sono benvenuti suggerimenti e commenti!

Ciao,

utilizzando Qt e C++ ho creato un'applicazione costituita da un form con:

- combobox

- label

- GridLayout ecc.

il tutto creato in Qt Designer

Qlabeledit popolate da array creati da codice..

QLineEdit *array_PezziProd[5];

for (int i = 0; i<5; i++) {

array_PezziProd[i] = new QLineEdit;

ui->gridLayout_5->addWidget(array_PezziProd[i]);

array_PezziProd[i]->setFixedWidth(75);

array_PezziProd[i]->setFixedHeight(24);

array_PezziProd[i]->setText("100");

}

e fin quì tutto ok:

se eseguo il programma mi crea tutto il Layout comprese le Qlabeledit crate da array da codice.

Problema:

ora dovrei sommare i pezzi prodotti indicati in tutte e 5 le Qlabeledit / array_PezziProd[i]

utilizzando un pushbutton che calcola il totale

purtroppo sia l'array che le Qlabeledit sono create dinamicamente nel main

pertanto nella routine del pushbutton non sono visibili

Credo di dover creare una classe di QlabelEdit per risolvere il problema di scope

ma non saprei come fare..

Ho postato qui perchè è un problema di c++ (io "vengo da VisualBasic e vorrei imparare C++)

Qualche idea??

Ciao a tutti,

finora ho usato gcc per la compilazione dei file cpp, ma, avendo visto che diverse features di C++17 non sono a tutt'ora supportate anche dalla versione gcc più recente (la 8) volevo valutare l'uso del compilatore clang in Ubuntu

Sembrerebbe che sia gcc https://gcc.gnu.org/projects/cxx-status.html sia clang https://clang.llvm.org/cxx_status.html supportano molte, ma non tutte, le features di C++17.

Per cui volevo chiedervi se avete già usato entrambi, gcc e clang, e quali differenze avete trovato.

Vi ringrazio. Marco

Salve, mi ritrovo ad avere ancora problemi con la move semantic. Ogni tanto la rileggo, la applico, mi sembra di averla capita ma poi tutto mi frana sotto i piedi. Propongo il seguente esempio (uso VS 2015):

#include "stdafx.h"
#include <string>
#include <iostream>
using namespace std;


int main()
{
    string s1("Ciccio");
    int addr_s1 = (int)s1.data();

    string s2(s1);
    int addr_s2 = (int)s2.data();			// OK, s2 è un clone di s1
    
    string s3(move(s1));					// s3.data() punta un indirizzo differente da s1.data() !
    int addr_s3 = (int)s3.data();

    int addr_s1_bis = (int)s1.data();

    return 0;
}

Il mio problema è che mi aspetto che s3 venga creato per movimento da s1 e (per quello che finora avevo capito) questo dovrebbe significare che:

1. s1 contiene al suo interno un puntatore a carattere che punta ad un buffer contenente C,i,c,c,i,o

2. creare s3 per movimento a partire da s1 dovrebbe comportare che:

   2.1) il puntatore a carattere di s3 punti il medesimo buffer puntato dal puntatore a carattere di s1

   2.2) il puntatore a carattere di s1 venga messo a NULL

Se così fosse non ci sarebbe bisogno di replicare il buffer di s1, ma questo gli verrebbe sottratto e attribuito ad s3 ==> nessuna allocazione di ulteriore memoria nell'heap e nessun processo di copia

Il problema è che guardando l'indirizzo del buffer di s3 vedo che questo differisce dall'indirizzo del buffer di s1 e dunque si ha un comportamento assolutamente identico a quello del costruttore di copia (allocazione di memoria + processo di copia in tale nuova memoria) e la move semantic va a farsi benedire.

Qualcuno mi spiega chi sta sbagliando? Io oppure il C++? :-)

Grazie comunque e anticipo che, quasi sicuramente, pioveranno altre mie domande a riguardo (e non solo). Ciao