Ich habe eine Klasse. Im Zuge der Erzeugung eines Objektes dieser Klasse wird ein Vektor angelegt (im konkreten Fall ausgelesen).

Class Auto
{   int kilometer;
    int preis;
}
Class Fuhrpark
{   int bezeichnung;                                
    vektor <Auto> LKW;  // Vektor wird bei Initialisierung mit Objekten der Klasse Auto "befüllt
                        // jedenfalls kann ich bei der Initialisierung auf den Vektor zugreifen
                        // LKW[0].kilometer funktioniert jedenfalls
}

int main ()
{
    Fuhrpark Norddeutschland;     // Erzeugen eines Objektes der Klasse Fuhrpark

// Wie kann ich jetzt auf den Vektor zugreifen / Es geht ja nicht wie bei einer Variable
// Norddeutschland.LKW[1].kilometer funktioniert ja hier nicht
}

mit meinem begrenzten Wissen vermute ich, dass es daran liegt, dass der Vektor nur innerhalb des Konstruktors der Klasse Fuhrpark "gültig"
ist. Oder liege ich da falsch?
Muss ich den Vektor dem Heap zuweisen oder ähnliches um ihn später zu nutzen oder kann ich den Vektor ähnlich einer Variablen (Bezeichnung) 
so deklarieren, dass man auf ihn auch außerhalb des Konstruktor zugreifen kann?

Ich hoffe ich liege nicht komplett falsch.

Es geht ja nicht wie bei einer Variable

Warum? Es ist eine Variable.

Aber wie du dem entnehmen kannst: An sich muss der vector irgendwie gefüllt werden, bevor du auf den Inhalt zugreifen kannst. Von alleine entsteht da nichts. Ein Zugriff auf nicht-existierende Inhalte kann funktionieren, wenn man Pech hat. Dann merkt man nicht, dass das Programm fehlerhaft ist. Aber es ist auf jeden Fall ein Fehler.

Inhalte bekommt man auf vielerlei Weise in den vector. Am wohl häufigsten benutzt werden push_back (Element hinten anhängen) und die Konstruktoren des vectors (Da gibt es viele verschiedene. Varianten sind: Ein Element X-Mal erzeugen; einen anderen Vector kopieren; beliebige Datenmengen übernehmen, die irgendwie einen definierten Anfang und Ende haben; eine Liste von Daten übernehmen). Aber auch viele andere Methoden bringen Inhalte in einen vector:
http://en.cppreference.com/w/cpp/container/vector/operator%3D (Inhalte von anderem Vector übernehmen)
http://en.cppreference.com/w/cpp/container/vector/assign (ähnliche Varianten wie beim Konstruktor, aber eben auch nach Konstruktion des Vectors nutzbar)
http://en.cppreference.com/w/cpp/container/vector/insert (Inhalte an bestimmter Stelle einfügen)
http://en.cppreference.com/w/cpp/container/vector/emplace (Inhalte an bestimmter Stelle erzeugen)
http://en.cppreference.com/w/cpp/container/vector/emplace_back (Element hinten erzeugen)
http://en.cppreference.com/w/cpp/container/vector/resize (Größe ändern, wofür nötigenfalls Kopien eines bestimmten Werts gemacht werden)
http://en.cppreference.com/w/cpp/container/vector/swap (Inhalte mit anderem Vector tauschen)

Wenn der Vector Member einer Klasse ist, dann möchtest du der Klasse wahrscheinlich einen eigenen Konstruktor mit einer Initialisierungsliste verpassen, um bei Erzeugen der Klasse einen passenden Konstruktor für den Vector aufzurufen. Wenn du nicht weißt, was eine Initialisierungsliste ist: Im Lehrbuch nachgucken oder googeln.

PS: Aber ansonsten ist, wie manni66 schon sagte, absolut kein Unterschied zu anderen Variablen. Es ist eine ganz normales Objekt, wie alle¹ anderen auch. Und auf alles anderen Objekte solltest du auch nie zugreifen, ohne ihnen einen Inhalt gegeben zu haben. Beim vector sind die Möglichkeiten dafür eben besonders vielfältig.

¹: Nun, nicht alle Objekte sind wie alle anderen. Für C-Arrays gelten beispielsweise ein paar Sonderregeln. Aber der Vector ist so wie das, was du als "normale" Objekte bezeichnen würdest.

Daher zeige bitte immer relevanten Code und Fehlermeldung des Compilers!

Fuhrpark::Fuhrpark(void)
{
    int bezeichnung = Norddeutschland; 
    vector <Auto> LKW;

    ifstream datei ("......LKW.txt");
    while (datei >> kilometer >> Char<';'> >> preis >> Char<';'>;) 
    {   
	Auto neuerLKW (kilometer, preis);
	LKW.push_back(neuerLKW);
    }
}

Hier liegt wahrscheinlich der Fehler, oder? / will euch nicht mit dem kompletten Code der verschiedenen Dateien quälen. Das wäre zu lang.

Das es funktioniert hab ich am einfachen Beispiel probiert:

#include <iostream>
#include <vector>

using namespace std;

class Auto
{public:
    int kilometer = 100;
    int preis = 200;
};

class Fuhrpark
{public:
    Fuhrpark()
    {
        methode();
    }
    int bezeichnung;
    vector <Auto> LKW;

    void methode ()
    {
        Auto A;
        Auto B;
        LKW.push_back(A);
        LKW.push_back(B);
        cout << LKW[0].kilometer << endl;
    }
};

int main()
{
    Fuhrpark Deutschland;
    Deutschland.methode();

    return 0;
}

Es funktioniert wie von manni vorrausgesagt!

@ Sepp: der Vektor war schon befüllt - hab auch in der while-Schleife beim einlesen durch ausgabe testen lassen (nicht mit im Code - wäre sonst zu lang geworden)

Ich erstell jetzt den Vektor durch eine Methode - das scheint ja zu klappen / ich bin mal gespannt

Wenn der Vector Member einer Klasse ist, dann möchtest du der Klasse wahrscheinlich einen eigenen Konstruktor mit einer Initialisierungsliste verpassen, um bei Erzeugen der Klasse einen passenden Konstruktor für den Vector aufzurufen. Wenn du nicht weißt, was eine Initialisierungsliste ist: Im Lehrbuch nachgucken oder googeln.

Man sollte sich schon genau überlegen ob man Initialisierungslisten für einen Konstruktor verwendet.
Wenn Mehrdeutigkeiten entstehen wird kompromisslos zugunsten des Initialisierungslisten-Konstruktors aufgelöst. Bezogen auf das obige Beispiel: Definiere für Auto einen impliziten cast nach int und Fuhrpark könnte nie wieder Konstruktor für den Member bezeichnung annehmen.
Zugegeben, der cast mag für das Beispiel lächerlich sein. Es existiert aber nun mal eine unnötige Abhängigkeit von Typparameter T, die maßgeblich beeinflusst ob ein Konstruktor überhaupt noch aufrufbar ist.
Ein std::vector als Argument verursacht solche Probleme nicht.

Ein std::vector als Argument verursacht solche Probleme nicht.

Hier liegt der Hund im Pfeffer begraben - Ich danke euch für eure Geduld mit mir!

Ich hab als Anfänger zwar schon mit Namensräumen experimentiert aber da ich erstmals jetzt versuche wirklich OO zu programmieren und h. sowie cpp. Dateien zu erstellen habe ich das wohl ganz verhauen und mich auf andere sachen konzentriert

Ein std::vector als Argument verursacht solche Probleme nicht.

Hier liegt der Hund im Pfeffer begraben - Ich danke euch für eure Geduld mit mir!

Ich hab als Anfänger zwar schon mit Namensräumen experimentiert aber da ich erstmals jetzt versuche wirklich OO zu programmieren und h. sowie cpp. Dateien zu erstellen habe ich das wohl ganz verhauen und mich auf andere sachen konzentriert

Hier kannst du dir bei Bedarf mal den Zugriff via Indexoperator ansehen.

#include <iostream>
#include <vector>

class Auto
{
	friend std::ostream& operator<<(std::ostream&, const Auto&);

	int kilometer;
	int preis;

public:
	Auto(int km = {}, int pr = {}) noexcept
		: kilometer{ km }, preis{ pr } { }
};

std::ostream& operator<<(std::ostream& os, const Auto& a) {
	return (os << a.kilometer << ' ' << a.preis);
}

class Fuhrpark
{
	int bezeichnung;
	std::vector<Auto> lkw;

public:
	Fuhrpark(int bz) noexcept
		: bezeichnung{ bz } { }

	Auto& operator[](int n) {
		if (n < 0 || n >= lkw.size())
			throw std::out_of_range{ "Indexueberschreitung." };
		return lkw[n];
	}

	Fuhrpark& add(const Auto& a) {
		lkw.push_back(a);
		return *this;
	}

	decltype(auto) size() const { return lkw.size(); }

	decltype(auto) begin() { return lkw.begin(); }
	decltype(auto) end() { return lkw.end(); }

	using size_type = std::vector<Auto>::size_type;
};
int main(int argc, char** argv) {
	Fuhrpark norddeutschland{ 1 };
	norddeutschland.add(Auto{ 10, 89000 })
		.add(Auto{ 89, 90000 })
		.add(Auto{ 100,40000 });

	for (Fuhrpark::size_type i = 0; i < norddeutschland.size(); ++i)
		std::cout << norddeutschland[i] << std::endl;

	//	Alternativ:
	for (auto const& it : norddeutschland)
		std::cout << it << std::endl;

	std::cin.clear();
	return std::cin.get();
}

Der Code ist in wenigen Sekunden entstanden und sollte nicht genauer untersucht werden als nötig. Für Lernzwecke kann man das vielleicht noch grade so als ausreichend bezeichnen.