Dynamisch addieren

Hi @ all,
ich habe folgendes Problem:
Es wird eine Variable deklariert:
int var[10];

Die werte die var[10] haben kann sollen alle addiert werden.
Allerdings ist die Anzahl derer die addiert werden immer anders.
Das heißt also
es könnte so aussehen:
var[1] + var[2]
oder auch var[1] + var[2] +var[3] + var[3].
Die zahl in den Klammern ist in dem Fall eine Variable die in einer Schleife immer kleiner wird
und in Beispiel 1 bei 2 anfängt und in Beispiel 2 bei 4.

Das Problem ist, ist das ich nicht weiß wie ich das Lösen kann, das er immer genau so wiele Werte addiert wie er soll.

#include <iostream>
using namespace std;

int main()
{
int var[10]
int zeahler = 4;

while(zeahler != 0)
{
?? = var[zeahler] ???
//Hier weiß ich nicht weiter
zeahler = zeahler -1;
}
system("PAUSE");
return 0;
}
Das Programm ist um einiges länger aber irgendwie bekomm ich das nicht hin....

Ich hoffe es ist einigermaßen zu verstehen was ich meine.
Vielleicht könnt ihr mir helfen!

Mit besten Grüßen
Lennart

Bitte cpp-tags verwenden.

int main()
{
    int var[10];
    //var muss noch definiert werden
    int num_toadd=4; // Wieviele Werte sollen addiert werden?
    int sum = 0;
    for(int i=0;i<num_toadd;++i)
    {
        sum+=var[i];
    }
    // sum beinhaltet jetzt die Summe der Variablen var[0] bis var[3]
}

Hallo,
DANKE!
Endlich, jetzt kann ich bin den Richtigen Sachen weitemachen!
Das war ein super Tipp, danke!
Besten Gruß!

Leider kann man Anhand eines Arrays (unbestimmter Größe) nicht mehr seine Größe ermitteln.
Das folgende Fragment wertet den Ausdruck zur Compilierzeit aus und ist deswegen
nicht für den dynamische Größen geeignet:

int var[10];
std::cout << (sizeof(var)/sizeof(int)) << std::endl;

Anders kannst du nur immer die Größe explizit "mitschleppen".
Oder du programmierst C++ unter Verwendung der STL. Der std::vector kennt z.B.
seine Größe und ist einem (dynamischen) Array ähnlich.

Etwa so:

#include <vector>

int main()
{
	std::vector<int> vec;
	int size = 7;
	for(int i=0; i<size; ++i){
		vec.push_back(i);
	}
	int sum = 0;
	//for(std::vector<int>::const_iterator it = vec.begin(); it != vec.end(); ++it){
	//	sum += *it;
	//}
	for(int i = 0; i< vec.size(); ++i){
		sum += vec[i];
	}
    std::cout << "Summe: " << sum << std::endl;
	std::cout << "Größe: " << vec.size() << std::endl;
}

Die etwas elegantere (aber für Anfänger schwerer zu verstehende) Version habe ich auskommentiert.

Gruß,
CSpille

.filmor

Für Summen gibt es std::accumulate.

int sum = std::accumulate (vec.begin (), vec.end (), 0);