Konstantendefinition im Header

neuer_nutzer

Hallo,

ich hätte im Prinzip gern das folgendes funktioniert:

#ifndef CONST_HPP
#define CONST_HPP

#include "stdafx.h"
#include <vector>
#include <iostream>

#include "Input.hpp"    //da steht "void input(Matrix &A, Matrix &B);" etc. drin

using namespace std;

typedef vector<double> v;    
typedef vector<v> matrix;   

        matrix A,B;

        input(A,B);

        //Nach input sollen A,B Konstanten sein

#endif

Ich hätte gern einen Header CONST in dem 2 Matrizen A,B als Konstanten gespeichert werden nachdem ich die Werte von A und B über die Funktion input(A,B) eingelesen habe.
Sinn der Sache soll sein, dass ich in meinen Programmteilen, in denen ich A und B brauche, einfach den Header einbinden kann.
Nur leider funktionieren meine Versuche so nicht. Vielleicht hat auch wer ne andere, bessere Lösung.

Danke schonmal

pumuckl

neuer_nutzer schrieb:

Nur leider funktionieren meine Versuche so nicht.

Grandiose Fehlerbeschreibung...

Was deine input-Funktion angeht: Wenn eine Funktion etwas berechnet, dann sollte das der Rückgabewert sein. Übergabe per Referenz, also als out-Parameter ist bestenfalls oldscool und nicht üblich, weil kontraintuitiv.

Wenn du Konstanten haben willst, musst du sie auch const deklarieren. Damit du keine Linkerfehler wegen Mehrfachdefinitionen bekommst, müsstest du die Definition in eine eigene Übersetzungseinheit auslagern und die Globalen dann als extern deklarieren.

Die Lösung ist, nicht mehrere Programmteile von den selben Matrizen abhängig zu machen. Das wäre sowieso ungut, da du damit eine relativ starke Kopplung der verschiedenen Programmteile erreichen würdest, die man vermeiden sollte.

neuer_nutzer

pumuckl schrieb:

Grandiose Fehlerbeschreibung...

Ich hab keine Fehlerbeschreibung angegeben weil ich kein Problem mit einem konkreten Fehler habe, sondern mir eher die Ideen fehlen wie ich das von mir gewollte richtig umsetze.

Anders erklärt:
Ich hab sowas in der Art:

int solve1(const Matrix &A, const Matrix &B, int x, int y, int z);
int solve2(const Matrix &A, const Matrix &B, int a, int b, int c);

Statt nun immer A und B wieder zu übergeben, mach ich sowas:

#include "Konstanten.hpp"

int solve1(int x, int y, int z);
int solve2(int a, int b, int c);

solve1 und solve2 können dann auf A und B im Header zugreifen und ich brauche die nicht immer zu übergeben.
Mach das überhaupt Sinn oder sollte ich die lieber immer mit übergeben? (In meinem Programm sind es natürlich ein paar mehr Werte die übergeben werden).

Dravere

Das hört sich für mich so an, als wenn du vergisst, dass es in C++ Klassen gibt:

class Solver
{
private:
  Matrix m_lhs;
  Matrix m_rhs;

public:
  Solver(Matrix const& lhs, Matrix const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
  {
  }

public:
  int solve1(int x, int y, int z) const; // const garantiert, dass in der Klasse nichts verändert wird.
  int solve2(int a, int b, int c) const;
};

Oder ich habe dein Problem nicht verstanden ... (schlechte "Fehlerbeschreibung")

Grüssli

hartmut1164

Wenn ich Dich richtig verstehe, willst Du Daten ueberall lesbar haben, ohne sie in der Parameterliste zu deklarieren.

Wenn es um Daten handelt, die nur in einem C/C++-File sichtbar sein sollen, so koennen sie global declariert werden:

int iUeberall;

void TueEtwas_0 (void)
{
    iUeberall++;
}

void TueEtwas_1 (void)
{
    iUeberall * 2;
}

int main (void)
{
    iUeberall = 8;
    TueEtwas_0 ();
    TueEtwas_1 ();
    return iUeberall;

}

Wenn das ueber mehrere File reichen soll, so erfolgt die Declartion mit "extern":

http://www.cppreference.com/wiki/keywords/extern

---

Ist aber meistens kein guter Stil, weil der Datenfluss nicht mehr sichtbar und zusaetzliche Abhaeinigkeiten erzeug werden.

neuer_nutzer

Hallo hartmut1164,
du hast das schon richtig erkannt
Allerdings hät ich gern Konstanten die über mehrere Files reichen sollen.
Das wäre dann also was mit extern const ... wäre das dann guter Stil? Eher nicht oder?
Mein Programm ist nämlich schon fertig und ich würde mich gern noch ein bisschen an einem guten Stil versuchen.

Wahrscheinlich werde ich das Ganze mal , wie Dravere meinte, über Klassen versuchen.
Danke für eure Antworten.

Xebov

Du kannst sie in C++ dateien als extern deklarieren dann sind sie in allen dateien sichtbar in denen sie drinstehen. Aber const wirst du sie damit wohl nicht bekommen, und deveres idee ist heir passender als globals, von denen solte man nur soviele wie nötig haben, sonst gehts schnell zu lasten der übersicht.

hartmut1164

erledigt

Nexus

Xebov schrieb:

Du kannst sie in C++ dateien als extern deklarieren dann sind sie in allen dateien sichtbar in denen sie drinstehen. Aber const wirst du sie damit wohl nicht bekommen

Du meinst sicher Variablen. Aber warum soll const nicht möglich sein?

Xebov schrieb:

und deveres idee

Draveres Idee.

Xebov

Nexus schrieb:

Xebov schrieb:

Du kannst sie in C++ dateien als extern deklarieren dann sind sie in allen dateien sichtbar in denen sie drinstehen. Aber const wirst du sie damit wohl nicht bekommen

Du meinst sicher Variablen. Aber warum soll const nicht möglich sein?

Ja natürlich Variablen. Ich habs selber noch nicht versucht aber eine const global würde ja erst zur Laufzeit nach eienr Berechnung gefüllt und da Existiert die Variable ja schon.

Nexus schrieb:

Xebov schrieb:

und deveres idee

Draveres Idee.

Ups

Nexus

Xebov schrieb:

Ich habs selber noch nicht versucht aber eine const global würde ja erst zur Laufzeit nach eienr Berechnung gefüllt und da Existiert die Variable ja schon.

Wenn dem so wäre, müssten const -Variablen immer mit konstanten Ausdrücken initialisiert werden. Offensichtlich ist dem aber nicht so; hier ein Beispiel:

const int a = func();