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

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]
}

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

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