Deklarieren von Variablen innerhalb von Funktionen einer Klasse in C++

MyFill ist eine Klasse und MyFill2 ist eine Funktion innerhalb dieser Klasse.

Was ist der Unterschied zwischen der Deklaration einer variable innerhalb der öffentlichen Funktion der Klasse wie folgt aus (Dicke und Linientyp) -->

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
    );
}

...und nur deklarieren Sie im private-label (private:), wie in der header-Datei -->

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

Den ersten richtig funktioniert. Aber die zweite nicht. Wenn ich wählen Sie die zweite option, was muss ich tun? Eine richtige code mit einer kurzen Erklärung helfen könnte.

was funktioniert nicht?
Ich war immer ein Fehler: nur statische Konstante Integrale Datenmember können innerhalb einer Klasse initialisiert

InformationsquelleAutor ridctg | 2013-07-24

c++class variables

5

Sind Sie nicht berechtigt, zuweisen von Werten zu Variablen innerhalb des Gültigkeitsbereichs der Klasse, Sie können dies nur innerhalb einer Funktion oder im globalen Bereich.
```
class MyFill {
public:
MyFill(Mat img1, Point center1);
void MyFill2 (Mat img, Point center);
private:
int thickness;
int lineType;
};
```
Ihre header muss geändert werden, um die oben genannten. Setzen Sie dann Ihre Werte in jeder Funktion, die Sie wollen, vorzugsweise Konstruktor in etwa so:
```
MyFill::MyFill(Mat img1, Point center1)
{
     thickness = -1;
     lineType = 8;
}
```
Edit - Um deine Frage in den Kommentaren:

Bezeichner für Variablennamen in function-Parameter nicht übereinstimmen müssen zwischen Deklaration und definition, nur die Typen und Ihre Reihenfolge müssen übereinstimmen. Es macht es klarer, aber nicht erforderlich.

Einen Funktionsprototyp ist wirklich nur gesehen wie die folgenden:
```
void MyFill2(Mat, Point);
```
Geben, wenn Sie es eine definition, dass bei der Vergabe der Identifier für Sie wirklich zählt:
```
void MyFill2(Mat m, Point p)
{
    //....
}
```
- Ist es nicht widersprüchlich, was billz oben gesagt? "Von der Platzierung und Dicke Linientyp in der Klasse Rahmen, Sie sind Mitglied der Klasse MyFill, und es gibt Sie in allen MyFill Objekte."
- diejenigen Variablen, die im Konstruktor noch in der Klasse scope. Sie sind gerade initialisiert daher die :. Sie sind nicht lokal. Tut mir Leid, ich verstehe nicht, die Frage 🙁
- Lassen Sie mich zu aktualisieren, um es klarer.
- Thnx. Ich brauche mehr Informationen. Jede Antwort, die ich bekam hier "MyFill(Mat img1, Zeigen center1); void MyFill2 (Mat img, Point center);" Aber ich bin mit "MyFill(Mat img1, Zeigen center1); void MyFill2 (Mat img, Point center);" funktioniert Es noch. Aber ich will wissen, welches der richtige ist und warum.
- Der eine ist ein Konstruktor und die andere ist nur eine Funktion mit den gleichen Argumenten. Sie sind beide richtig und es gibt absolut nichts falsch mit, dass Sie beide in Ihrer Klasse.
- Ich glaube, ich verstehe, was Sie jetzt sagen. Bezeichner für Variablennamen in function-Parameter nicht übereinstimmen müssen zwischen Deklaration und definition, nur die Typen und Ihre Reihenfolge müssen übereinstimmen.
- Ja. Das ist es, was ich wissen wollte. Es scheint komisch zu mir, dass kann ich mit beiden ähnlich und unterschiedliche Variablen-Namen in dem beschriebenen Kontext. Könnten Sie bitte ein wenig Erklärung?
- Erklärung im edit oben
- Danke! ist die Sache jetzt klarer!
- vielen Dank für Ihre durchdachte Antwort und Erklärung! Können Sie sagen, was ist der bessere Stil? Ich denke, wenn die variable wird nur lokal benötigt, ist es besser, einfach zu erklären, lokal, richtig?
InformationsquelleAutor Joseph Pla
2

Du erklären die member-Variablen in der definition der Klasse, dann in den Konstruktor verwenden Sie eine Initialisierungsliste zur Initialisierung der member-Variablen:
```
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);
}
```
- Seit C++11-Initialisierung in der Deklaration der Klasse ist auch möglich.
- Initialisierungsliste... ich denke, das ist, was ich brauche, zu verwenden. Danke @Joachim
- Ich bin mit VS2010. Das ist, warum ich bin immer der Fehler???
- Vielleicht. Ich glaube nicht, verwenden MSVC, also, ich kann Ihnen nicht sagen, was C++11-features unterstützt.
InformationsquelleAutor Some programmer dude

Was ist der Unterschied zwischen der Deklaration einer variable innerhalb der öffentlichen Funktion der Klasse wie folgt aus (Dicke und Linientyp)

Dicke und Linientyp definiert werden Funktionsumfang, es heißt lokale variable von MyFill2 Funktion.

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

}

Indem Dicke und Linientyp in Klasse Anwendungsbereich, Sie sind Mitglied der Klasse MyFill, und es gibt Sie in allen MyFill Objekte.

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, könnten Sie zum initialisieren der Klasse in den Initialisierungsliste

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

Hoffe, das beantwortet Ihre Frage.

Danke. Ich denke, das ist die Antwort. Ich werde es jetzt versuchen.
Kein problem, froh, dass es geholfen hat.

InformationsquelleAutor billz

1

können Sie nicht zuweisen Werte in der class-Deklaration.
Sie sollten tun, dass in den Konstruktor der Klasse:
```
class MyFill {
public:
    MyFill(Mat img1, Point center1);
private:
    int thickness ;
    int lineType;
};

MyFill::MyFill(Mat img1, Point center1) : thickness(-1), lineType(8) {
  //...
}
```
- Beachten Sie, dass seit C++11 können Sie initialisieren die Schüler in der Klasse Erklärung.
- Dank umläute und bald!
- große Hilfe sein, aber bewusst sein, dass stackoverflow-Politik schreckt danke posts.
InformationsquelleAutor umläute
1

Im ersten Fall deklarieren Sie lokale Variablen gelten nur innerhalb der Funktion Bereich. Außerhalb, können Sie Sie verwenden.

In die letztere erklärt Sie für den Umfang der Klasse, so könnte man verweisen Sie in eine beliebige Funktion der Klasse.

Beachten Sie, dass Ihr Stil der Initialisierung funktioniert nur, wenn Sie eine C++11-konformen compiler, die mit C++03, müssten Sie initialisieren Sie diese im Konstruktor:
```
MyFill::MyFill(Mat img1, Point center1)
    : thickness(-1), lineType(8)
{ /* ... */ }
```
und nur zu erklären als
```
private:
    int thickness;
    int lineType;
```
Wenn Sie nur benötigen diese Variablen, die einer Funktion mit lokalen Variablen.
- Vielen Dank... Diese Antwort ist Häufig, Und ich werde es versuchen
InformationsquelleAutor nijansen
0

C++11 erlaubt die Initialisierung von nicht-const-und nicht-statische member innerhalb der Klasse Erklärung, Sie können sich an den Diskussionen in diesem Seite

InformationsquelleAutor yichucai

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.