华为题库-进制转换

题目：

题目描述

写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入 ）

输入描述:
输入一个十六进制的数值字符串。

输出描述:
输出该数值的十进制字符串。

示例1 输入 复制
0xA
输出 复制
10

知识点：

1.pow(a,b) 以a为底，b的指数

int x;
int y = pow(x,2)  //y=x^2

2.strlen(str)计算字符串的长度，从代表该字符串的第一个地址开始遍历，直到遇到结束符’\0’，即回车符为结束标志。返回的长度大小不包括’\0’。
当 string 中含有空字符’\0’，使用 strlen() 获取 string 的长度时会被截断，使用成员函数 length() 和 size() 可以返回 string的真实长度。

c/c++ strlen(str)和str.length()和str.size()都可以求字符串长度。
其中str.length()和str.size()是用于求string类对象的成员函数
strlen(str)是用于求字符数组的长度，其参数必须是是char。*

strlen():返回字符数组或字符串所占的字节数
（1）针对字符数组
（2）针对字符指针

char str[10] = { '1','2' }; //填0或者不填是指空数组
char ch[5] = "123";//"123"实际上是const char[4]，因为计算到"\0"的位置，因此是3+1=4

函数原型：strlen(const char[]);
strlen是string length(字符串长度)的缩写｡它是测试字符串长度的函数｡其函数的值为字符串中的实际长度,不包括′\0′在内｡

如 char str[10]=″China″; cout<

C++ string 获取长度时，我们经常使用以下两种方法。

//方法一：调用length()或size()
string strTest="test";
strTest.length();			//结果为4
strTest.size();				//结果为4

//方法二：转为C风格字符串，调用strlen()
strlen(strTest.c_str());	//结果为4

举例：

1）char* ss = "0123456789";

sizeof(ss)为4，ss是指向字符串常量的字符指针，sizeof 获得的是指针所占的空间,则为4
sizeof(*ss)为1，*ss是第一个char字符，则为1

2）char ss[] = "0123456789";

sizeof(ss)为11,ss是数组，计算到'\0'位置，因此是(10+1)
sizeof(*ss)为1,*ss是第一个字符

3）char ss[100] = "0123456789";

sizeof(ss)为100，ss表示在内存中预分配的大小，100*1
strlen(ss)为10，它的内部实现用一个循环计算字符串的长度,直到'\0'为止。

4）int ss[100] = "0123456789";

sizeof(ss)为400，ss表示在内存中预分配的大小，100*4
strlen(ss)错误，strlen参数只能是char*，且必须是以'\0'结尾

5）char[] a={'a','b','c'};
sizeof(a)的值应该为3。

char[] b={"abc"};
sizeof(b)的值应该是4。

若string str={'a','b','c','\0','X'};
那么sizeof(str)为5，strlen(str)为3。

3.str.length()计算字符串的长度
c++中的size()和length()没有区别

string str="0123456789";
cout <<"str.length()="<<str.length()<<endl;//结果为10
cout <<"str.size()="<<str.size()<<endl;//结果为10

4.sizeof是一个操作符（operator）。其作用是返回一个对象或类型所占的内存字节数。sizeof(str)是计算str所占的内存空间，比如一开始定义str[10]={0};则sizeof(str)=10。
sizeof的值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。
sizeof():返回所占总空间的字节数
（1）对于整型字符型数组
（2）对于整型或字符型指针

sizeof有三种语法形式：

1） sizeof (object); //sizeof (对象)

2） sizeof object; //sizeof 对象

3） sizeof (type_name); //sizeof (类型)

对象可以是各种类型的变量，以及表达式（一般sizeof不会对表达式进行计算）。

sizeof对对象求内存大小，最终都是转换为对对象的数据类型进行求值。

sizeof (表达式); //值为表达式的最终结果的数据类型的大小

int i；
sizeof(int); //值为4  
sizeof(i); //值为4，等价于sizeof(int)  
sizeof i; //值为4  
sizeof(2); //值为4，等价于sizeof(int)，因为2的类型为int  
sizeof(2 + 3.14); //值为8，等价于sizeof(double)，因为此表达式的结果的类型为double  

数组的sizeof值等于数组所占用的内存字节数。

注意：
1）当字符数组表示字符串时，其sizeof值将’/0’计算进去。
2）当数组为形参时，其sizeof值相当于指针的sizeof值。

    char a[10];  
    char n[] = "abc";   
    cout<<"char a[10]"<<sizeof(a)<<endl;//数组，值为10  
    cout<<"char n[] = /"abc/" "<<sizeof(n)<<endl;//字符串数组，将'/0'计算进去，值为4

void func(char a[3])  
{  
    int c = sizeof(a); //c = 4，因为这里a不在是数组类型，而是指针，相当于char *a。  
}  
  
void funcN(char b[])  
{  
    int cN = sizeof(b); //cN = 4，理由同上。  
} 

指针是用来记录另一个对象的地址，所以指针的内存大小当然就等于计算机内部地址总线的宽度。

在32位计算机中，一个指针变量的返回值必定是4。

指针变量的sizeof值与指针所指的对象没有任何关系。

char *b = "helloworld";  
char *c[10];  
double *d;  
int **e;  
void (*pf)();    
  
cout<<"char *b = /"helloworld/"     "<<sizeof(b)<<endl;//指针指向字符串，值为4  
cout<<"char *b                    "<<sizeof(*b)<<endl; //指针指向字符，值为1  
cout<<"double *d                  "<<sizeof(d)<<endl;//指针，值为4  
cout<<"double *d                  "<<sizeof(*d)<<endl;//指针指向浮点数，值为8  
cout<<"int **e                  "<<sizeof(e)<<endl;//指针指向指针，值为4  
cout<<"char *c[10]                "<<sizeof(c)<<endl;//指针数组，值为40  40=4*10  有10个元素
cout<<"void (*pf)();              "<<sizeof(pf)<<endl;//函数指针，值为4  

5.char ch[5] = "123";//"123"实际上是const char[4]
定义了一个字符型数组，维数为5。
“123”实际上是const char[4]，注意这里是维数为4，因为计算到“\0”的位置，因此是3+1=4。

在字符串数组的每一个元素中存放一个字符串,而不是一个字符｡字符串数组里的每一个元素都是字符串类型。 如果用字符数组存放字符串,一个元素只能存放一个字符,用一个一维字符数组存放一个字符串｡字符数组里的每一个元素都是字符类型，所有字符共同组成一个字符串。

6.gets()函数
从stdio流中读取字符串，直至接受到换行符或EOF时停止。读取的换行符被转换为‘\0’空字符，并由此来结束字符串。
读入成功，返回与参数相同的指针；读入过程中遇到EOF(End-of-File)或发生错误，返回NULL指针。
7.getline（cin，input）
当 cin 读取数据时，它会传递并忽略任何前导白色空格字符（空格、制表符或换行符）。一旦它接触到第一个非空格字符即开始阅读，当它读取到下一个空白字符时，它将停止读取。
为解决cin的读取到空白字符会停止的问题，使用getline（cin，input）函数，cin 是正在读取的输入流，而 input是接收输入字符串的 string 变量的名称。

 string name;
 string city;
 cout << "Please enter your name: ";
 getline(cin, name);
 cout << "Enter the city you live in: ";
 getline(cin, city);
 cout << "Hello, " << name << endl;
 cout << "You live in " << city << endl;

代码：

void test01()
{
	//字符型数组两种定义方式
	char str[10] = { '1','2' }; //填0或者不填是指空数组
	char ch[5] = "123";//"123"实际上是const char[4]，因为计算到"\0"的位置，因此是3+1=4
	
	//string字符串数组
	string str2[11] = {"12","sdf","3556" };
	
	//字符串
	string str3;
	
	cin >> str3;
	
	cout << str << endl; //输出12  因为str是字符型数组，str就是依次输出里面的各个字符      如果为空数组，则输出空
	cout << *str << endl;//输出1   数组名代表首地址，也就是指向第一个元素'1'的指针，通过*解引用   如果为空数组，则输出为空
	cout << strlen(str) << endl; //输出2  因为str中有两个元素      如果为空数组，则输出0，由于str为空，因此输出0
	cout << sizeof(str) << endl; //输出10，因为str定义时为str[10]
	cout << size(str) << endl; //输出10，因为str定义时为str[10]
	cout << "------------------" << endl;

	cout << *str2<< endl; //输出12，数组名代表数组的首地址，即指向第一个元素的地址，也就是指针，通过*来解引用，因此输出第一个元素
	cout << str2 << endl; //动态输出，因为数组名代表数组的首地址，这是动态分配的。
	cout << str2->length() << endl;//输出2，对应指针指向元素的长度，也就是"12"的长度，因此为2
	cout << str2->size() << endl;//输出2，对应指针指向元素的长度，也就是"12"的长度，因此为2
	cout << sizeof(str2) << endl;//输出308，sizeof不能返回动态分配的内存空间大小
	cout << size(str2) << endl;//输出11，因为str2在定义时为str2[11]
	
	cout << "------------------" << endl;

	cout << str3 << endl;//输出字符串str3
	cout << str3.length() << endl; //输出str3字符串的长度
	cout << str3.size() << endl; //输出str3字符串的长度

	cout << "------------------" << endl;

	cout << ch << endl; //输出123，因为ch字符数组里的元素为'1','2','3'
	cout << *ch << endl; //输出1，因为数组名代表数组的首地址，也就是指向第一个元素'1'的指针,通过*解引用
	cout << strlen(ch) << endl; //输出3，因为ch里有三个元素
	cout << sizeof(ch) << endl; //输出5，因为ch定义时为ch[5]
	cout << size(ch) << endl;//输出5，因为ch定义时为ch[5]

	cout << "------------------" << endl;

	for (int i = 0; i < strlen(str); i++)
	{
		cout << str[i] << endl;
	}//输出1 2，因为str[0]='1',str[1]='2' 
	//如果为空数组，则无输出，因为strlen(str)=0
	cout << "------------------" << endl;

	for (int i = 0; i < str2->length(); i++)
	{
		cout << str2[i] << endl;
	}//输出12 sdf,因为str2[0]="12",str2[1]="sdf",str2->length()=2，所以只遍历了前两个元素
	cout << "------------------" << endl;

	for (int i = 0; i < size(str2); i++)
	{
		cout << str2[i] << endl;
	}//输出12 sdf 3556 和8个空行，因为str2[0]="12",str2[1]="sdf",str2[2]="3556"，其余为空无输出，由于endl因此输出换行
	cout << "------------------" << endl;

	for (int i = 0; i < str3.length(); i++)
	{
		cout << str3[i] << endl;
	}//输出str3里的字符
	cout << "-------------------" << endl;

	for (int i = 0; i < strlen(ch); i++)
	{
		cout << ch[i] << endl;
	}//输出1 2 3，因为ch[0]='1',ch[1]='2',ch[2]='3'。
}

思路：

法一：定义一个char类型的数组用于存放通过gets_s()输入的字符串；从倒数第一个字符遍历到整数第三个结束；‘1’-‘0’=‘1’,故只需要进行ch[i]-'0’即可；十六进制里‘B’-‘A’=1，但是B对应的是11，所以再’加上10，即ch[i]-‘A’+10；由于十六进制不区分大小写，‘b’-‘a’=1,但是’b’对应’B’是11，所以需要加上10，即ch[i]-‘b’+10。

gets_s()是更安全的写法，gets()的升级版。

法一代码：

void Hex_conversion()
{
	char ch[100];
	while (gets_s(ch))
	{
		int result = 0;
		for (int i = strlen(ch) - 1; i > 1; i--)
		{
			if (ch[i] >= '0'&& ch[i] <= '9')
			{
				result += (ch[i] - '0') * pow(16, strlen(ch) - 1 - i);
			}
			else if (ch[i] >= 'A'&&ch[i] <= 'F')
			{
				result += (ch[i] - 'A' + 10)*pow(16, strlen(ch) - 1 - i);
			}
			else if (ch[i] >= 'a'&&ch[i] <= 'f')
			{
				result += (ch[i] - 'a' + 10) * pow(16, strlen(ch) - 1 - i);
			}
		}
		cout << result << endl;
	}
}

法二：
通过cin>>hex>>a
此时比如输入12，则输入的12位0x12（十六进制），但是a的值为216^0
+116^1=18，即此时a为十进制18。

法二代码：

#include
#include
#include
#include
 
using namespace std;

int main(){
    int a;
    while(cin>>hex>>a){
        cout<<a<<endl;
    }
    return 0;
}