Vil af med en warning

Forsvinder de ikke hvis du eksplicit typecaster:

uint64_t i = (uint64_t)pow(...

?

Du mangler da også en parantes?

Jeg er ikke helt hjemme i c++-syntaksen, men virker dette?
uint64_t i = (uint64_t) pow(talsystem, (antal-1);
eller
uint64_t i = (uint64_t) pow(talsystem, (antal-1));

Med gcc:

#include <inttypes.h>
#include <math.h>

int main()
{
  uint64_t i = pow(10,10);
  return 0;
}

w.cpp: In function `int main()':
w.cpp:6: warning: initialization to `uint64_t' from `double'
w.cpp:6: warning: argument to `long long unsigned int' from `double'

#include <inttypes.h>
#include <math.h>

int main()
{
  uint64_t i = (uint64_t)pow(10,10);
  return 0;
}

no warnings !

>>arne
Det virker. Gider du ikke lige smide et svar hvor du fortæller lidt om hvad eksplicit typecaster betyder. Udfra koden kan jeg godt regne ud hvad den gør men hvordan virker den?

type cast = konvertering fra en data type til en anden data type

int i;
double d;
d = 123.456;
i = d; // implicit konvertering fra double til int
i = (int)d; // eksplicit konvertering fra double til int

Det er værd at bemærke at det kun er double->int der giver warnings
ikke int->double.

Forklaringen er den indlysende at (normalt) kan en int repræsenteres
fint i en double, mens en double ofte vil miste nogle decimaler når
den konverteres til int.

Hvis vi taler C++ vil jeg varmt anbefale de nye typecast operatorer:

static_cast
dynamic_cast
reinterpret_cast

De er gode, dels fordi det er ret nemt at se om der bliver lavet en typecast eller ej, dels fordi de deler typecasts op i tre kategorier, som er ret forskellige.

static_cast bruges til at konvertere mellem "de samme" typer (eksempelvis fra en taltype til en anden taltype).

dynamic_cast bruges til at gendanne tabt typeinformation (eksempel: Du har to typer, A og B, B nedarver fra A. Du har en vector med A*'ere, men ved at nogle af elementerne faktisk er af typen B. Så kan du lave my_b = dynamic_cast<B*> my_a; my_b bliver 0 hvis cast'en ikke kan lade sig gøre, altså hvis B ikke nedarver fra A. Der er andre finter med dynamic_cast, men her er altså den korte version).

reinterpret_cast er den "rå" cast. Du har en klump hukommelse af en eller anden type, og du ved at den tilfældigvis kan betragtes som type A, selvom den er af type B. Så kan du lave en my_b = reinterpret_cast<B*>(my_a), hvor my_a er en pointer til A.

reinterpret_cast er ikke portabel, så resultatet er oversætterafhængigt.

Hvis vi tager den med:

#include <iostream>

using namespace std;

int main()
{
  int i;
  double d;
  d = 123.456;
  i = d; // implicit konvertering fra double til int - will often give warning
  cout << i << endl;
  i = (int)d; // eksplicit konvertering fra double til int (C style)
  cout << i << endl;
  i = int(d); // eksplicit konvertering fra double til int (C++ style)
  cout << i << endl;
  i = static_cast<int>(d); // eksplicit konvertering fra double til int (new C++ style)
  cout << i << endl;
  return 0;
}

Jeg synes at den er sidste er en grim konstruktion. Men muligvis er jeg bare
for gammeldags.

arne_v> Bjarne Stroupstrup er enig med dig. Det er derfor de nye cast-operatorer ser ud som de gør. De *skal* være grimme, så det er nemt at se hvad der foregår :-). Ulempen ved gammeldags cast er at det kan være svært at se i et komplekst udtryk hvad der bliver cast'et, og casts kan bruges til mere end en ting. Det er det som Bjarne har villet rydde op i. Det synes jeg egentlig er lykkedes ganske godt. Se i øvrigt www.boost.org for andre interessante cast-operatorer (herunder numeric_cast).