C++ upphöjt med variabler? (Nybörjare)

#define _USE_MATH_DEFINES
#include<cmath>
#include<iostream>
using namespace std;

int main()
{
setlocale(LC_ALL, "");
double Belopp, Ränta, Tid, Slutkapital, Förändringsfaktor, Förändringsfaktor2;
cout << "Ange Belopp: ";
cin >> Belopp;
cout << "\nAnge räntesats (%) : ";
cin >> Ränta;
cout << "\nAnge antal år: ";
cin >> Tid;
cout << "\n" << endl;
Förändringsfaktor = Ränta*0.01+1;
Förändringsfaktor2=double pow(double Förändringsfaktor, double Tid); //upphöjt?
Slutkapital = Ränta*Belopp;
cout << "Efter " << Tid << " år har ditt kapital stigit till " << Slutkapital << " :-" << endl;
system("pause");
return 0;
}

tror det bör lösa sig om du tar bort double framför pow.

Edit ser inte heller varför du måste ange double som typ för dina parametrar, tror det är fel men har inte skrivit någon c++ på rätt länge.

funkar det om du skriver så här?

Förändringsfaktor2= pow(Förändringsfaktor, Tid);

Jupp, detta löser problemet

Slutkapital = Ränta*Belopp;

Slutkapital = Förändringsfaktor2*Belopp;

Bara för att tillägga så kan du tänka på att när du hämtar värden från funktioner ska du inte skriva med vad du förväntar dig för värde (Det är vad du gjort för fel och vad de två tidigare nämnt), utan det du måste se till att komma ihåg är att variabeln du sätter värdet till är av rätt typ (Vilket den i detta fallet är, som du ser på rad 114 där du initierar den).

Extratips: Man brukar skriva variabelnamn med liten bokstav i början. Stora bokstäver i början brukar man bara använda till klasser

Du behöver inte skriva "double" varje gång du använder en variabel av typen double. Det gör du bara i deklarationen, dvs där du skapar variabeln. Sedan använder du bara variabelns namn.

edit: extratips 2: man brukar även använda "int" som heltalsvariabel och "float" som flyttalsvariabel (för decimaltal). Större datatyper såsom double eller long tar mycket onödig minnesplats brukar bara användas när man vill lagra extremt stora tal som inte får plats annars.

Om inte pow funkar varför inte bygga en (exemple ej testat att kompillera):

double powerUp(double value, int power){
   double res=0;
   if(value<0){
      res=1/value;
      for(short i=0; i<=power; i++){
         res+=res*1/value;
      }
      return res;
   }
   res=value;
   for(short i=0; i <= power; i++){
      res+=res*value
   }
   return res;
}

Kan ha tänkt fel (Lite trött).

Till sist, det fina med C språksläkten är att man kan överlagra operatorer (googla hur, väldigt enkelt). Så du kan göra om ^ tecknet till att faktiskt vara upphöjt med. Bra övning för dig i framtiden när du hunnit koda lite mer.

Lycka till!

Skickades från m.sweclockers.com

Tanken var att matte matematiskt räcka men det var helt fel ser jag nu.
Men enligt matten vet vi för negativa potsen:

x^(-1) => 1/x
x^(-2) => 1/x*1/x
x^(-3) => 1/x*1/x*1/x
...
...

för positiva potenser:

x^(1) => x
x^(2) => x*x
x^(3) => x*x*x
...
...

och att x^0 = 1 oavsätt x.

Då kan vi skriva följande potens funktion:

// Det första double i funktions namnet är för vi
// vill att svar ska vara i double form.
// double inom () är för vi vill kunna skicka in t,ex
// 0.5 => x=0.5 (om du kollar hur jag beskrivit potenser
// via matte innan)
// int inom () är för vi vill bara ha heltals up höjningar.
// om vi skulle vilja göra uphöjningar för icke heltal hade det
// blivit jobbigare.
double powerUp(double value, int power){
	double res=1.0;
	// Negativa potenser
	if(power<0){
		for(short i = 0; i>power; i--){
			res*=1.0/value;
		}
	// När x^0
	} else if(power==0){
		res=1.0;
	// positiva potenser.
	} else{
		for(short i = 0; i<power; i++){
			res*=value;
		}
	}
	return res;
}

Vilket vi kan använda i vårt program på följande sätt:

#include <iostream>

using namespace std;

// Det första double i funktions namnet är för vi
// vill att svar ska vara i double form.
// double inom () är för vi vill kunna skicka in t,ex
// 0.5 => x=0.5 (om du kollar hur jag beskrivit potenser
// via matte innan)
// int inom () är för vi vill bara ha heltals up höjningar.
// om vi skulle vilja göra uphöjningar för icke heltal hade det
// blivit jobbigare.
double powerUp(double value, int power){
	double res=1.0;
	// Negativa potenser
	if(power<0){
		for(short i = 0; i>power; i--){
			res*=1.0/value;
		}
	// När x^0
	} else if(power==0){
		res=1.0;
	// positiva potenser.
	} else{
		for(short i = 0; i<power; i++){
			res*=value;
		}
	}
	return res;
}

int main(){
	// Skriva ut direkt
	cout << "2 to the power of 6 is: " << powerUp(2, 6) << endl;
	cout << "2 to the power of -2 is: " << powerUp(2.0, -2) << endl;
	cout << "2 to the power of 0 is: " << powerUp(2, 0) << endl;

	// Spara till variable
	double test = powerUp(2,4);
	// Skriva ut variablen.
	cout << "2 to the power of 4 is: " << test << endl;

	// Vi kan även använda oss av variabler:
	double base=4;
	int powVal=6;
	double ans = powerUp(base, powVal);
	cout << base << " to the power of " << powVal << " is: " << ans << endl;
	// Eller
	base = powerUp(base,powVal);
	cout << "The anser is: " << base << endl;


	return 0;
}

För vi har skapat en funktion som räknar våra potenser. Om du inte använder denna kod gör det inget, om inget annat hoppas jag att det lärde dig lite i c++.

Att implementera sin egen pow-funktion kan vara en bra övning för att lära sig hur det fungerar, men mycket mer än så är det inte. pow i standardbiblioteket är vältestad, optimerad och hanterar alla specialfall som kan uppstå. Den enda orsaken att använda din egen implementation är om pow är för långsam för dina behov, och du t.ex. klarar dig med en grov uppskattning.

Detsamma gäller för övrigt mycket annat i C++. C++ har ett stort standardbibliotek som du i de allra flesta fall bör använda. Att implementera t.ex. din egen strängklass kan vara en lärosam upplevelse som många går igenom, men när du gjort det så kan du lika gärna slänga den och använda t.ex. std::string istället. Om du sen blir kunnig nog för att implementera saker på ett bättre sätt än standardbiblioteket så har du förhoppningsvis förnuft nog att veta om det är en bra idé eller inte.