Dichiarazione di variabili all'interno delle funzioni di una classe in C++

Question

MyFill è una classe e MyFill2 è una funzione all'interno di tale classe.

Qual è la differenza tra dichiarare una variabile all'interno la funzione pubblica della classe come questa (spessore e tipo di linea) ->

MyFill::MyFill (Mat img, Point center) 
{ 
    MyFill2 (img, center); 
} 

void MyFill::MyFill2(Mat img, Point center) 
{ 
    int thickness = -1; 
    int lineType = 8; 
    circle (
     img, 
     center, 
     w/32, 
     Scalar(0, 0, 255), 
     thickness, 
     lineType 
    ); 
} 

... e proprio dichiarandoli in private label (:) privato , come nel file di intestazione ->

class MyFill { 
public: 
    MyFill(Mat img1, Point center1); 
    void MyFill2 (Mat img, Point center); 
private: 
    int thickness = -1; 
    int lineType = 8; 
}; 

Il primo funziona correttamente. Ma il secondo no. Se voglio andare con la seconda opzione, cosa devo fare? Un codice giusto con qualche spiegazione potrebbe aiutare.

Answer 1

Non è consentito assegnare valori alle variabili all'interno dell'ambito della classe, è possibile farlo solo all'interno di una funzione o nell'ambito globale.

class MyFill { 
public: 
MyFill(Mat img1, Point center1); 
void MyFill2 (Mat img, Point center); 
private: 
int thickness; 
int lineType; 
}; 

L'intestazione deve essere modificata come sopra. È quindi impostare i valori in qualsiasi funzione che ti piace, preferibilmente il vostro costruttore in questo modo:

MyFill::MyFill(Mat img1, Point center1) 
{ 
    thickness = -1; 
    lineType = 8; 
} 

Edit - Per la tua domanda nei commenti:

identificatori per i nomi delle variabili nei parametri di funzione non è necessario corrispondere tra dichiarazione e definizione, solo i tipi e il loro ordine devono corrispondere. Lo rende più chiaro, ma non è necessario.

un prototipo di funzione è davvero visto solo come il seguente:

void MyFill2(Mat, Point); 

Quando si dà una definizione, cioè quando l'assegnazione di identificatori che conta davvero:

void MyFill2(Mat m, Point p) 
{ 
    //.... 
} 

Answer 2

È dichiara le variabili membro nella definizione della classe, quindi nel costruttore si utilizza un elenco di inizializzazione per inizializzare le variabili membro:

class MyFill { 
public: 
    MyFill(Mat img1, Point center1); 
    void MyFill2 (Mat img, Point center); 

private: 
    // Just declare the member variables 
    int thickness; 
    int lineType; 
}; 

// ... 

MyFill::MyFill(Mat img1, Point center1) 
    : thickness(-1), lineType(8) // Initializer list to initialize the member variables 
{ 
    MyFill2(img1, center1); 
} 

Answer 3

non è possibile assegnare valori nella dichiarazione di classe. si dovrebbe fare che nel costruttore della classe:

class MyFill { 
public: 
    MyFill(Mat img1, Point center1); 
private: 
    int thickness ; 
    int lineType; 
}; 

MyFill::MyFill(Mat img1, Point center1) : thickness(-1), lineType(8) { 
    // ... 
} 

Answer 4

Nel primo caso, si dichiarano variabili locali che sono validi solo nell'ambito della funzione. Fuori, non puoi usarli.

In quest'ultimo, li hai dichiarati per l'ambito della classe, in modo da poterli fare riferimento in qualsiasi funzione di quella classe.

Nota che il tuo stile di inizializzazione funziona solo se si utilizza un compilatore C++ 11 conforme, con C++ 03 si avrebbe bisogno di inizializzarle nel costruttore:

MyFill::MyFill(Mat img1, Point center1) 
    : thickness(-1), lineType(8) 
{ /* ... */ } 

e solo dichiarare loro come

private: 
    int thickness; 
    int lineType; 

Se sono necessarie solo queste variabili in quella funzione, andare con le variabili locali.

Answer 5

Qual è la differenza tra dichiara una variabile all'interno funzione pubblica della classe simili (spessore e tipo di linea)

spessore e tipo di linea sono definiti in funzione portata, si chiama variabile locale della funzione MyFill2.

void MyFill::MyFill2(Mat img, Point center) 
{ 
    int thickness = -1; // thickness is a local variable in MyFill2, 
         // it's destroyed when MyFill2 function goes out of scope 
         // thickness is not accessable in any other member function of MyFill 
         // or object. 
    int lineType = 8; // same here 

} 

Inserendo spessore e tipo di linea in classe portata, sono membro della classe MyFill, e sono disponibili in tutti gli oggetti MyFill.

class MyFill { 
private: 
    int thickness = -1; // this is a C++11 form of initialize class member. 
         // In C++03, you need to initialize them in constructor 
         // thickness is a member of MyFill, it will exist in all life of MyFill object. 
    int lineType = 8; 
}; 

In C++ 03, si potrebbe inizializzare membro della classe nella lista di inizializzazione membro

MyFill::MyFill(Mat img1, Point center1) 
    : thickness(0), lineType(0) // Initializer list to initialize the member variables 
{ 
} 

Spero che questo risponde alla tua domanda.

Answer 6

Il C++ 11 permette l'inizializzazione di non-const e membri non statici all'interno dichiarazione di classe, si può fare riferimento alle discussioni in questo page