http://blog.csdn.net/pipisorry/article/details/25346379

c++基本数据类型

什么样的数据算是byte类型,int类型,float类型,double类型,long类型？

byte类型,就是字符类型.这类数据是字符组成的
FLOAT,为数字浮点型,其小数点后面能够跟N个数字
DOUBLE,为双精度数字类型,其小数点后仅仅能有两个数字

int类型

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcGlwaXNvcnJ5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" width="584" height="284" />

上面提到了在32位机器和64机器中int类型都占用4个字节。

后来，查了The C Programming language这本书，里面有一句话是这种：Each compiler is free to choose appropriate sizes for its own hardware, subject only to the restriction that shorts and ints are at least 16bits, longs are at least 32bits, and short is no longer than int, which is no longer than long.意思大致是编译器能够依据自身硬件来选择合适的大小，可是须要满足约束：short和int型至少为16位，long型至少为32位，而且short型长度不能超过int型，而int型不能超过long型。这即是说各个类型的变量长度是由编译器来决定的，而当前主流的编译器中通常是32位机器和64位机器中int型都是4个字节（比如。GCC）。

以下列举在GCC编译器下32位机器和64位机器各个类型变量所占字节数：

C类型

	32	64
char	1	1
short int	2	2
int	4	4
long int	4	8
long long int	8	8
char*	4	8
float	4	4
double	8	8

关于带符号与无符号类型：整型 int、stort 和 long 都默觉得带符号型。

要获得无符号型则必须制定该类型为unsigned，比方unsigned long。

unsigned int类型能够简写为unsigned。也就是说，unsigned后不加其它类型说明符就意味着是unsigned int。

Note:
c语言中int类型为4bytes（64位机上，32位机应该也是），也就是说总是4bytes而不会变，只是不同语言定义的范围不同，如python中是8bytes(64位机)实际对象占用28bytes。
#include <stdio.h>
#include <limits.h>
int main()
{
    printf("The value of INT_MAX is %i\n", INT_MAX);
    printf("The value of INT_MIN is %i\n", INT_MIN);
    printf("An int takes %ld bytes\n", sizeof(int));
   return 0;
}
The value of INT_MAX is 2147483647
The value of INT_MIN is -2147483648
An int takes 4 bytes

一字节表示八位，即：1byte = 8 bit;
int: 4byte = 32 bit 有符号signed范围：2^31-1 ~ -2^31即：2147483647 ~ -2147483648 无符号unsigned范围：2^32-1 ~ 0即：4294967295 ~ 0
long: 4 byte = 32 bit 同int型
double: 8 byte = 64 bit 范围：1.79769e+308 ~ 2.22507e-308
long double: 12 byte = 96 bit 范围： 1.18973e+4932 ~ 3.3621e-4932
float: 4 byte = 32 bit 范围： 3.40282e+038 ~ 1.17549e-038
int、unsigned、long、unsigned long 、double的数量级最大都仅仅能表示为10亿，即它们表示十进制的位数不超过10个，即能够保存全部9位整数。

而short仅仅是能表示5位。

皮皮blog

c++类型转换

1. c++中string到int的转换

1) 在C标准库里面。使用atoi：

#include <cstdlib>
#include <string>

std::string text = "152";
int number = std::atoi( text.c_str() );
if (errno == ERANGE) //可能是std::errno
{
//number可能因为过大或过小而不能全然存储
}
else if (errno == ?

?

?

?

)
//可能是EINVAL
{
//不能转换成一个数字
}

2) 在C++标准库里面。使用stringstream：(stringstream 能够用于各种数据类型之间的转换)

#include <sstream>
#include <string>

std::string text = "152";
int number;
std::stringstream ss;

ss << text;//能够是其它数据类型
ss >> number; //string -> int
if (! ss.good())
{
//发生错误
}

ss << number;// int->string
string str = ss.str();
if (! ss.good())
{
//发生错误
}

3) 在Boost库里面，使用lexical_cast：

#include <boost/lexical_cast.hpp>
#include <string>

try
{
std::string text = "152";
int number = boost::lexical_cast< int >( text );
}
catch( const boost::bad_lexical_cast & )
{
//转换失败
}

[怎样将字符串转换int64_t]

int转换成string

c++中将输入的数字以字符（串）形式输出

#include <iostream>
#include <sstream>
#include <string>
using namespace std;
void main(){
int i = 65;
cout<<char(i)<<endl; //输出‘A' <=>printf("%c\n", i);
stringstream ss;
ss<<i;
string s;
ss>>s;
cout<<s<<endl; //输出”65“
char *c = new char;
itoa(65, c, 10);
cout<<c<<endl; //输出”65“
//cout<<strcmp(c, "65")<<endl;
}

[http://bbs.csdn.net/topics/390401758?

page=1#post-394058528]

2.string 转 CString

CString.format(”%s”, string.c_str());
用c_str()确实比data()要好；

3.char 转 CString

CString.format(”%s”, char*);

4.char 转 string

string s(char *);
仅仅能初始化。在不是初始化的地方不妨用assign().

5.string 转 char *

char *p = string.c_str();

6.CString 转 string

string s(CString.GetBuffer());
GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间.

7.字符串的内容转换为字符数组和C—string

(1) data(),返回没有”\0“的字符串数组
(2) c_str()，返回有”\0“的字符串数组
(3) copy()

8.CString与int、char*、char[100]之间的转换

(1) CString互转int

将字符转换为整数。能够使用atoi、_atoi64或atol。而将数字转换为CString变量，能够使用CString的Format函数。如
CString s;
int i = 64;
s.Format(”%d”, i)
Format函数的功能非常强。值得你研究一下。

void CStrDlg::OnButton1()
{
   CString
   ss=”1212.12″;
   int temp=atoi(ss);
   CString aa;
   aa.Format(”%d”,temp);
   AfxMessageBox(”var is ” + aa);
}

(2) CString互转char*

///char * TO cstring
CString strtest;
char * charpoint;
charpoint=”give string a value”; //?
strtest=charpoint;

///cstring TO char *
charpoint=strtest.GetBuffer(strtest.GetLength());

(3) char *转成CString

标准C里没有string,char *==char []==string, 能够用CString.Format(”%s”,char *)这种方法来将char *转成CString。

要把CString转成char *，用操作符（LPCSTR）CString就能够了。

CString转换 char[100]
   char a[100];
   CString str(”aaaaaa”);
   strncpy(a,(LPCTSTR)str,sizeof(a));

static_cast类型转换

static_cast < type-id > ( expression )

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有例如以下几种使用方法：

①用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。

进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；

进行下行转换（把基类指针或引用转换成派生类表示）时。因为没有动态类型检查。所以是不安全的。

②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发者来保证。

③把空指针转换成目标类型的空指针。

④把不论什么类型的表达式转换成void类型。

注意：static_cast不能转换掉expression的const、volatile、或者__unaligned属性。

C++primer第五章里写了编译器隐式运行不论什么类型转换都可由static_cast显示完毕;reinterpret_cast通常为操作数的位模式提供较低层的又一次解释

1、C++中的static_cast运行非多态的转换，用于取代C中通常的转换操作。

因此。被做为显式类型转换使用。比方：

inti;

floatf = 166.71;

i = static_cast<int>(f);

此时结果，i的值为166。

2、C++中的reinterpret_cast主要是将数据从一种类型的转换为还有一种类型。所谓“通常为操作数的位模式提供较低层的又一次解释”也就是说将数据以二进制存在形式的又一次解释。

比方：

inti;

char*p = "This is an example.";

i = reinterpret_cast<int>(p);

此时结果，i与p的值是全然同样的。reinterpret_cast的作用是说将指针p的值以二进制（位模式）的方式被解释为整型，并赋给i，//i 也是指针。整型指针；一个明显的现象是在转换前后没有数位损失。

尽管const_cast是用来去除变量的const限定，可是static_cast却不是用来去除变量的static引用。

事实上这是非常easy理解的。static决定的是一个变量的作用域和生命周期。比方：在一个文件里将变量定义为static，则说明这个变量仅仅能在本Package中使用；在方法中定义一个static变量，该变量在程序開始存在直到程序结束；类中定义一个static成员，该成员随类的第一个对象出现时出现，而且能够被该类的全部对象所使用。对static限定的改变必定会造成范围性的影响，而const限定的仅仅是变量或对象自身。

但不管是哪一个限定，它们都是在变量一出生（完毕编译的时候）就决定了变量的特性。所以实际上都是不容许改变的。这点在const_cast那部分就已经有体现出来。

static_cast和reinterpret_cast一样。在面对const的时候都无能为力：两者都不能去除const限定。两者也存在的非常多的不同，比方static_cast不仅能够用在指针和引用上。还能够用在基础数据和对象上；reinterpret_cast能够用在"没有关系"的类型之间，而用static_cast来处理的转换就须要两者具有"一定的关系"了。

reinterpret_cast能够在随意指针之间进行互相转换。即使这些指针所指的内容是毫无关系的。也就是说一下语句，编译器是不会报错的，可是对于程序来说也是毫无意义可言的。仅仅会造成程序崩溃

unsignedshort Hash( void *p ) {

unsignedlong val = reinterpret_cast<unsignedlong>( p );

return ( unsigned short )( val ^ (val >> 16));

}

int main() {

typedefunsignedshort (*FuncPointer)( void *) ;

FuncPointer fp = Hash; //right,this is what we want

int a[10];constint* ch = a; //right, array is just like pointer

char chArray[4] = {'a','b','c','d'};

fp = reinterpret_cast<FuncPointer> (ch); //no error, but does not make sense

ch = reinterpret_cast<int*> (chArray); //no error

cout <<hex<< *ch; //output: 64636261 //it really reinterpret the pointer

}

而以上转换，都是static_cast所不能完毕的任务，也就是说把上边程序里全部的reinterpret_cast换成static_cast的话，就会马上得到编译错误，因为目标指针和原始指针之间不存在"关系"

从上边的程序，也就一下子看出来了reinterpret_cast和static_cast之间最本质的差别。

可是从基类到子类的转换。用static_cast并非安全的，详细的问题会在dynamic_cast一篇阐述。

在指针和引用方便，似乎也仅仅有继承关系是能够被static_cast接受的，其它情况的指针和引用转换都会被static_cast直接扔出编译错误。而这层关系上的转换又差点儿都能够被dynamic_cast所取代。这样看起来static_cast运算符的作用就太小了。

实际上static_cast真正用处并不在指针和引用上。而在基础类型和对象的转换上。

而基于基础类型和对象的转换都是其它三个转换运算符所办不到的

from: http://blog.csdn.net/pipisorry/article/details/25346379

ref: