交换两个变量的值,不使用第三个变量的方法及实现
c语言交换函数
c语言交换函数
c语言交换函数是一种常见的编程技术，它能让两个变量的值交换，大大简化程序的开发。
在c语言编程中，它是一种非常重要的技术，它能让程序更易于编写和理解。
c语言交换函数是用来实现两个变量中的数值交换的函数。
它可以使得一个变量的值等于另一个变量的值，从而实现变量值的交换。
c语言的交换函数的语法如下：swap（&x，&y）;其中，x和y是用来交换的变量，&x和&y是变量的指针，表示x和y的地址。
c语言中的交换函数的实现原理是，先将x的值保存在一个临时变量中，然后将y的值放入x中，再将临时变量中的值放入y中，从而实现两个变量的值交换。
具体的实现代码如下：
int tmp;
tmp = x;
x = y;
y = tmp;
在实际的编程过程中，交换函数可以大大简化程序的开发。
通过它，我们可以很容易实现数值的交换，节省时间和精力，让程序的设计和实现更加便捷。
此外，c语言的交换函数还可以用于对象的交换，特别是那些复杂的对象。
它不仅可以交换简单的数值，还能交换指针、结构体、类和其他变量类型，这使得c语言编程更加方便。
另外，c语言的交换函数也很容易理解。
由于它的简单易懂，它
可以让初学者更容易掌握，也能减少开发过程中出现的错误。
总之，c语言的交换函数是一种非常重要的技术，它大大简化了程序的开发，让程序更易于编写和理解，也能节省时间和精力，让程序的设计和实现更加便捷。
它的使用不仅可以实现数值的交换，还可以实现对象的交换，因此在c语言编程中，它是一种非常重要的技术，不容忽视。
交换两个整型变量的值c语言
交换两个整型变量的值c语言交换两个整型变量的值是一个常见的编程问题。
在C语言中，有多种方法可以实现这个目标。
下面我将介绍三种常见的交换两个整型变量的方法：使用第三个变量、不使用第三个变量、使用异或运算。
1. 使用第三个变量这是最常见的方法之一。
它的实现方式是：首先将第一个变量的值赋给第三个变量，然后将第二个变量的值赋给第一个变量，最后将第三个变量的值赋给第二个变量。
以下是使用第一个变量实现交换的示例代码：```cvoid swap(int *a, int *b) {int temp = *a;*a = *b;*b = temp;}int main() {int num1 = 5;int num2 = 10;printf("交换前的值: num1=%d, num2=%d\n", num1, num2);swap(&num1, &num2);printf("交换后的值: num1=%d, num2=%d\n", num1, num2);return 0;}```2. 不使用第三个变量这种方法利用了算术运算和赋值运算之间的关系。
具体的实现方式是：将第一个变量的值与第二个变量的值相加，然后将和减去第二个变量的值，并将结果赋给第一个变量。
最后，将第一个变量的值减去第二个变量的值，并将结果赋给第二个变量。
以下是不使用第三个变量实现交换的示例代码：```cvoid swap(int *a, int *b) {*a = *a + *b;*b = *a - *b;*a = *a - *b;}int main() {int num1 = 5;int num2 = 10;printf("交换前的值: num1=%d, num2=%d\n", num1, num2);swap(&num1, &num2);printf("交换后的值: num1=%d, num2=%d\n", num1, num2);return 0;}3. 使用异或运算异或运算是一种位运算，它有一个重要的特性：两个相同的数进行异或运算的结果是0。
华为面试 笔试题目(附答案)
华为面试/笔试题目（附答案）陈晓明2010-05-21 15:45:59要查看更多华为笔经相关信息，请访问华为公司校园招聘club：深圳华为技术有限公司（1）什么是预编译，何时需要预编译：答案：１、总是使用不经常改动的大型代码体。
２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。
在这种情况下，可以将所有包含文件预编译为一个预编译头。
（2）char * const p char const * p const char *p 上述三个有什么区别？答案：char * const p; //常量指针，p的值不可以修改char const * p；//指向常量的指针，指向的常量值不可以改 const char *p； //和char const *p（3）char str1[] = "abc"; char str2[] = "abc"; const char str3[] = "abc"; const char str4[] = "abc"; const char *str5 = "abc"; const char *str 6 = "abc"; char *str7 = "abc"; char *str8 = "abc"; cout (y)?(y):(x)) //结尾没有‘；’（10）嵌入式系统中经常要用到无限循环，你怎么用c编写死循环。
答案：while(1){}或者for(;;)（11）关键字static的作用是什么？答案：定义静态变量（12）关键字const有什么含意？答案：表示常量不可以修改的变量。
（13）关键字volatile有什么含意？并举出三个不同的例子？答案：提示编译器对象的值可能在编译器未监测到的情况下改变。
位运算交换两个变量的值原理
位运算交换两个变量的值原理宝子！今天咱来唠唠一个超酷的东西——位运算交换两个变量的值。
你可能一听就觉得，啥？位运算？好高深的样子。
其实呀，没那么吓人啦。
咱先来说说普通的交换变量值的方法。
就像你有两个盒子，一个装着苹果，一个装着香蕉，你想把它们交换过来。
一般呢，就会找个临时的小盒子，先把苹果放进去，再把香蕉放到原来装苹果的盒子，最后把临时盒子里的苹果放到原来装香蕉的盒子。
在代码里呢，就是用一个临时变量来实现交换，这是大家都比较熟悉的做法。
但是呢，位运算就像是变魔术一样，不用这个临时变量就能交换。
你看哈，这里面用到的位运算主要是异或（^）操作。
异或这个操作可有意思啦，就像是两个调皮的小精灵在玩游戏。
对于两个二进制位来说，如果它们相同，异或的结果就是0；如果它们不同，异或的结果就是1。
比如说，有两个数a和b。
我们来做a = a ^ b这个操作。
这时候的a就像是被施了魔法一样，它变成了一个新的东西。
这个新的东西其实包含了a和b的一些特殊信息。
就好像a和b的一些小秘密被融合到了这个新的a里面。
然后呢，我们再做b = a ^ b。
哇哦，这时候的b就神奇地变成了原来的a啦。
你可以想象成之前a里面融合的那些小秘密，和现在的b一作用，就把原来的a给还原出来放在b这里了。
最后再做a = a ^ b。
这时候的a就变成了原来的b了。
是不是超级神奇呀？就像魔法棒一挥，两个变量的值就交换过来了。
从原理上讲呢，当我们做a = a ^ b的时候，a其实就变成了a和b的一种特殊组合。
然后b = a ^ b的时候，b就等于(a ^ b) ^ b。
根据异或的性质，(a ^ b) ^ b就等于a。
因为b和b异或就是0，0和a异或就是a。
最后a = a ^ b的时候，a就等于(a ^ b) ^ a，这又根据异或的性质等于b啦。
这就像是一场奇妙的数字舞蹈，每个数字都在按照异或的规则跳动着，最后就完成了这个看似不可思议的交换。
这种位运算交换变量值的方法，不仅很巧妙，而且在一些对性能要求比较高，对空间比较敏感的地方，就特别有用。
程序员笔试题
程序员笔试题1。
什么是预编译，何时需要预编译：2。
char * const pchar const * pconst char *p上述三个有什么区别？3。
char str1[] = "abc";char str2[] = "abc";const char str3[] = "abc";const char str4[] = "abc";const char *str5 = "abc";const char *str6 = "abc";char *str7 = "abc";char *str8 = "abc";cout << ( str1 == str2 ) << endl;cout << ( str3 == str4 ) << endl;cout << ( str5 == str6 ) << endl;cout << ( str7 == str8 ) << endl;4。
以下代码中的两个sizeof用法有问题吗？[C易]void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母{for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )if( 'a'<=str[i] && str[i]<='z' )str[i] -= ('a'-'A' );}char str[] = "aBcDe";cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;UpperCase( str );cout << str << endl;5。
慧通面试题
1.什么是预编译何时需要预编译：总是使用不经常改动的大型代码体。
程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。
在这种情况下，可以将所有包含文件预编译为一个预编译头。
2.char * const p;char const * pconst char *p上述三个有什么区别？char * const p; //常量指针，p的值不可以修改char const * p；//指向常量的指针，指向的常量值不可以改const char *p； //和char const *p 相同3.char str1[] = "abc";char str2[] = "abc";const char str3[] = "abc";const char str4[] = "abc";const char *str5 = "abc";const char *str6 = "abc";char *str7 = "abc";char *str8 = "abc";cout << ( str1 == str2 ) << endl;cout << ( str3 == str4 ) << endl;cout << ( str5 == str6 ) << endl;cout << ( str7 == str8 ) << endl;结果是：0 0 1 1解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。
4.以下代码中的两个sizeof用法有问题吗？void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母{for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )if( 'a'<=str[i] && str[i]<='z' )str[i] -= ('a'-'A' );}char str[] = "aBcDe";cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;UpperCase( str );cout << str << endl;答：函数内的sizeof有问题。
华为笔试题(附答案)
1什么是预编译，何时需要预编译：答：１）总是使用不经常改动的大型代码体。
２）程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。
在这种情况下，可以将所有包含文件预编译为一个预编译头。
2 char * const p char const * p const char *p 上述三个有什么区别？答： char * const p; //常量指针，p的值不可以修改char const * p；//指向常量的指针，指向的常量值不可以改const char *p； //和char const *p 相同3 char str1[] = "abc";char str2[] = "abc";const char str3[] = "abc";const char str4[] = "abc";const char *str5 = "abc";const char *str6 = "abc";char *str7 = "abc";char *str8 = "abc";cout < < ( str1 == str2 ) < < endl;cout < < ( str3 == str4 ) < < endl;cout < < ( str5 == str6 ) < < endl;cout < < ( str7 == str8 ) < < endl;结果是：0 0 1 1str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。
4 以下代码中的两个sizeof用法有问题吗？void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母{ for( size_t i=0; i <sizeof(str)/sizeof(str[0]); ++i )if( 'a' <=str && str <='z' ) str -= ('a'-'A' );}char str[] = "aBcDe";cout < < "str字符长度为: " < < sizeof(str)/sizeof(str[0]) < < endl;UpperCase( str );cout < < str < < endl;答案：函数内的sizeof有问题。
Python中四种交换两个变量的值的方法
Python中四种交换两个变量的值的⽅法Python中四种交换两个变量的值的⽅法
⽅法⼀:(所有语⾔都可以通过这种⽅式进⾏交换变量)
通过新添加中间变量的⽅式，交换数值.
下⾯通过⼀个demo1函数进⾏演⽰：
def demo1(a,b):
temp = a
a = b
b = temp
print(a,b)
⽅法⼆：（此⽅法是Python中特有的⽅法）
直接将a， b两个变量放到元组中，再通过元组按照index进⾏赋值的⽅式进⾏重新赋值给两个变量。
下⾯通过⼀个demo2函数进⾏演⽰:
def demo2(a,b):
a,b = b,a
print(a,b)
⽅法三：
通过简单的逻辑运算进⾏将两个值进⾏互换
下⾯通过⼀个demo3函数进⾏演⽰:
def demo3(a, b):
a = a + b
b = a - b
a = a - b
print(a, b)
⽅法四：
通过异或运算将两个值互换异或运算的原理是根据⼆进制中的 "1^1=0 1^0=1 0^0=0"
下⾯通过⼀个demo4函数进⾏演⽰:
def demo4(a,b):
a = a^b
b = a^b # b = (a^b)^b = a
a = a^
b # a = (a^b)^a = b
print(a,b)。
用异或实现交换两个值的原理
用异或实现交换两个值的原理异或（XOR）是一种位运算，它的运算规律是两个二进制数字的每一位，相同则为0，不同则为1。
我们可以用异或运算来实现交换两个值，在程序中经常用到这个技巧，让我们来探究一下用异或实现交换两个值的原理吧。
首先，让我们来看一下传统的交换两个变量的方法：``` int a = 10; int b = 20; int temp = a; a = b; b = temp; ```这段代码中，我们用一个临时变量temp来保存变量a 的值，然后将b的值赋给a，最后再将temp的值赋给b，这样就实现了a和b的交换。
然而，这种方法的缺点在于需要一个额外的变量temp 来保存值，如果我们要交换的两个变量非常大或者数量非常多，临时变量的开销就会变得非常大。
那么有没有一种更加高效的方法呢？答案是肯定的，我们可以使用异或运算来实现交换两个变量的值：``` int a = 10; int b = 20; a ^= b; b ^= a; a ^= b; ```这段代码中，我们首先将a和b进行异或运算，然后将结果赋值给a，再将a和b进行异或运算，将结果赋值给b，最后再将a和b进行异或运算，将结果赋值给a。
一定程度上说，这段代码可能会让一些人感到困惑，毕竟我们是如何做到不用临时变量就能交换两个值的呢？下面我们来解释一下用异或实现交换两个值的原理。
首先，我们假设a和b的值分别是x、y。
第一步：a ^= b，这个操作的结果是将a和b的二进制每一位进行异或，例如，如果x的二进制位是1010，y 的二进制位是1100，那么a ^= b的结果就是0110。
第二步：b ^= a，这个操作的结果是将b和a的二进制每一位进行异或，例如，如果x的二进制位是1010，y 的二进制位是1100，那么b ^= a的结果就是1010。
第三步：a ^= b，这个操作的结果是将a和b的二进制每一位进行异或，例如，如果x的二进制位是1010，y 的二进制位是1100，那么a ^= b的结果就是1100。
java的swap函数
java的swap函数Java的Swap函数Swap函数是一种在编程语言中非常有用的函数，它用于交换两个变量的值。
在Java中，Swap函数可以帮助我们更方便地操作变量，尤其是在排序和算法问题中。
Java语言是一种强类型语言，它不像C语言那样提供了一个可以直接交换变量值的Swap函数。
但是，我们可以通过其他的方法来模拟Swap函数的实现。
方法一：使用第三方变量一种实现Swap函数的方法是使用第三方变量。
这意味着我们需要创建一个新的变量来存储其中一个变量的值，然后将其值赋给另一个变量，再将新变量的值赋给第一个变量。
例如，如果我们想要交换变量x和y的值，我们可以这样做：int temp = x;x = y;y = temp;这种方法简单易懂，而且通用性也比较强，适用于不同类型的变量。
方法二：使用异或运算符另一种实现Swap函数的方法是使用异或运算符。
异或运算符是Java中的一个二元运算符，它可以对两个数的二进制位进行逻辑运算。
当两个数的对应位不同时，异或运算的结果为1，否则为0。
使用异或运算符可以避免创建一个新的变量，在一定程度上减少了代码的复杂度。
我们可以这样来实现交换两个变量的值：x = x ^ y;y = x ^ y;x = x ^ y;这个方法看起来有些神秘，但其实原理很简单。
首先，我们将x和y做异或运算，将其结果赋值给x，这时x的原值被存储在y中了。
然后，我们再将x和y做异或运算，将y的原值赋值给x，最后再将x和y做异或运算，将x的原值赋值给y。
需要注意的是，这种方法只适用于基本数据类型，对于对象类型的变量，可能会出现意想不到的问题。
方法三：使用数组一种更加简单的方法是，将需要交换的变量存储在一个数组中，然后交换数组中的元素。
例如，我们可以这样来交换变量x和y的值：int[] vals = {x, y};x = vals[1];y = vals[0];这个方法非常简单，也很直观，而且适用于各种变量类型。
两数交换位置的c语言
两数交换位置的c语言在C语言中，我们经常需要对变量进行交换位置的操作。
这个操作在很多场景中都非常有用，比如数组元素的排序、链表节点的交换等等。
本文将介绍如何使用C语言实现两个数的交换位置。
在C语言中，可以使用临时变量来实现两个数的交换位置。
具体的步骤如下：1. 定义两个变量，并赋予初始值。
假设这两个变量分别为a和b。
2. 创建一个临时变量temp，并将a的值赋给temp。
3. 将b的值赋给a，即a=b。
4. 将temp的值赋给b，即b=temp。
下面是一个示例代码，演示如何使用C语言实现两个数的交换位置：```c#include <stdio.h>int main() {int a = 10;int b = 20;int temp;printf("交换前：a = %d, b = %d\n", a, b);temp = a;a = b;b = temp;printf("交换后：a = %d, b = %d\n", a, b);return 0;}```运行上述代码，输出结果如下：```交换前：a = 10, b = 20交换后：a = 20, b = 10```可以看到，经过交换位置操作后，a的值变为了20，b的值变为了10，实现了两个数的交换。
除了使用临时变量来实现交换位置之外，还可以使用异或运算来实现两个数的交换。
异或运算的特点是，当两个操作数的某一位相同时，结果为0，否则为1。
因此，可以利用异或运算来实现两个数的交换位置。
下面是使用异或运算实现两个数交换位置的示例代码：```c#include <stdio.h>int main() {int a = 10;int b = 20;printf("交换前：a = %d, b = %d\n", a, b);a = a ^ b;b = a ^ b;a = a ^ b;printf("交换后：a = %d, b = %d\n", a, b);return 0;}```运行上述代码，输出结果与之前的示例代码相同。
用异或实现交换两个值的原理
用异或实现交换两个值的原理在编程中，经常会遇到需要交换两个变量的值的情况。
传统的方法是使用一个中间变量来实现交换，即通过一个临时变量将两个变量的值进行互换。
然而，使用异或操作也可以实现交换两个变量的值，而不需要借助额外的变量。
异或操作（^）是一种位运算，用于对两个二进制数的对应位进行比较，若相对应位值相同，则结果为0，若相对应位值不同，则结果为1。
换句话说，异或操作可以将两个数的对应位进行互换。
假设有两个变量a和b，它们的值分别为a_val和b_val。
要使用异或操作交换它们的值，可以按照以下步骤进行：1. 将a_val与b_val进行异或操作，将结果保存在a_val中。
此时，a_val的值为a_val ^ b_val。
2. 将a_val与b_val进行异或操作，将结果保存在b_val中。
此时，b_val的值为(a_val ^ b_val) ^ b_val，即a_val。
3. 将a_val与b_val进行异或操作，将结果保存在a_val中。
此时，a_val的值为(a_val ^ b_val) ^ a_val，即b_val。
经过这三步操作，a_val和b_val的值就完成了交换。
为了更好地理解这个过程，我们可以通过一个简单的例子来说明。
假设a_val的值为5，b_val的值为7。
按照上述步骤进行操作：1. a_val = a_val ^ b_val = 5 ^ 7 = 22. b_val = (a_val ^ b_val) ^ b_val = (2 ^ 7) ^ 7 = 2 ^ 0 = 23. a_val = (a_val ^ b_val) ^ a_val = (2 ^ 2) ^ 2 = 0 ^ 2 = 2最终，a_val的值变为了7，b_val的值变为了5，完成了两个变量值的交换。
使用异或操作实现交换的原理是利用了异或操作的性质：对于同一个数，连续进行两次异或操作，结果还是这个数本身。
在交换两个变量的值的过程中，将变量的值通过异或操作进行互换，最终可以实现交换。
a与b交换数值的三种方法
a与b交换数值的三种方法嘿，咱今儿就来唠唠 a 与 b 交换数值的三种方法哈！你想想看，这 a 和 b 就像两个小伙伴，有时候它们想互相换换位置，体验下对方的角色呢。
第一种方法呀，就像是玩个小游戏。
咱可以找个中间的“小裁判”c来帮忙。
先让 a 把自己的值给 c，这时候 a 就像大方地把自己的宝贝暂时交给了 c 保管。
然后呢，b 再把自己的值给 a，这就相当于 b 给了 a一份特别的礼物。
最后呀，c 再把之前保管的 a 的值给 b，嘿，你瞧，这不就完成交换啦！就好像是一场有趣的接力赛，a 把棒子给 c，b 再把棒子给 a，最后 c 把棒子给 b，多有意思呀！第二种方法呢，就有点像变魔术啦。
咱可以让 a 加上 b 的值，得到一个新的数字。
然后呢，让 b 等于原来的 a 减去现在的 b，这就像给 b来了个大变身。
接着，再让 a 等于那个新数字减去现在的 b，哇塞，就这么神奇地交换成功啦！是不是感觉很奇妙呀，就像魔术师轻轻挥动一下魔法棒，一切就都变了样。
还有第三种方法哦，这就像是一场巧妙的安排。
我们可以让 a 等于a 与b 的和减去 b，这就像是给 a 做了个特别的调整。
然后呢，让 b 等于 a 与 b 的和减去 a，嘿呀，你说妙不妙，它们俩就这么自然而然地交换啦！就好像是精心编排的一场舞蹈，每个动作都恰到好处。
这三种方法各有各的奇妙之处呀，你在实际运用中可以根据情况选择最合适的那一个。
不管是哪种方法，都能让 a 和 b 这两个小伙伴成功地交换数值，让它们在数字的世界里尽情地玩耍。
所以呀，下次遇到要交换 a 和 b 的数值，可别犯愁啦，选个喜欢的方法，轻松搞定！怎么样，是不是觉得很有意思呢？这就是数字的魅力呀，小小的交换也能带来大大的乐趣呢！。
C语言基础、经典：交换a、b值较好的方法
交换a、b的值在C语言的学习中是很常见的问题。
最常用的方法就是引入一个中间变量当做中间介质来交换a、b的值。
代码如下：v o id c ha ng e_ab(i n t*a,in t*b){in t te mp=0;te mp=*a;*a=*b;*b=t em p;}注意不能写为：v o id c ha ng e_ab(i n t a,i nt b){in t te mp=0;te mp=a;a=b;b=te mp;}普通的变量传递，则不会改变内存内容，以为普通变量作为参数时，其实是在内存块（栈空间）中新申请了一块空闲块，不是原来的内存块，而函数调用完毕之后，这块新申请的内存块会由于变量的作用域失效而被系统回收。
如果把指针作为实参进行传递，也就是把内存地址传了过去，那么操作这个指针所指向的内存块，必然会改变这个内存的内容了。
以上这种方法就是最常见的方法。
那么，你知道如何将a、b的值进行交换，并且不使用任何其他的中间变量？方法一：采用算术的方法v o id c ha ng e_ab(i n t*a,in t*b){*a=*a +*b;*b=*a -*b;*a=*a -*b;}方法二：采用异或的方法v o id c ha ng e_ab(i n t*a,in t*b){*a=*a ^*b;*b=*a ^*b;*a=*a ^*b;}方法一存在一个潜在的危险，当形参的类型改为无符号16位时，若a、b的值很大，那么a+b的值就有可能超出16位整数所能表示的范围，从而造成程序运行错误。
方法二则没有这个问题，这是一种比较好的方法。
python中如何调用函数交换两个变量的值
python中如何调⽤函数交换两个变量的值python中如何调⽤函数交换两个变量的值所有代码来在python3.7.1版本实现以下实例通过⽤户输⼊两个变量，并相互交换：⽅法⼀：def swap(a,b): # 创建临时变量，并交换temp = aa = bb = tempprint(a,b)以上实例中，我们创建了临时变量 temp ，并将 a 的值存储在 temp 变量中，接着将 y 值赋给 a，最后将 temp 赋值给 b变量。
⽅法⼆：def swap2(a,b):# 不使⽤临时变量a,b = b,aprint(a,b)Python以引⽤⽅式管理对象，你可以交换引⽤，但通常不能交换内存中的对象值。
在函数中,因为a,b是int的对象是原⼦类型，是不可变参数，他们直接的“引⽤”是值传递，这⾥的引⽤应该是值传递。
⽅法三：def swap3(a,b):"""^异或运算 1^1=0 1^0=1 0^0=0 x^0=x x^x=0"""a = a^bb = a^b # b = (a^b)^b = aa = a^b # a = (a^b)^a = bprint(a,b)异或运算，相同为0，不同为⾮0的数，例如1^1=0 1^0=1 0^0=0 x^0=x x^x=0⽅法三中 a = a ^ b , b = (a^b)^b = a, a = (a^b)^a = b推荐第⼆种写法，因为这是python语⾔的特性。
第三种写法，看起来就⽜B，可以⽤来吹⽜B，顺便装⼀B。
华为(嵌入式)笔试题
（1）什么是预编译，何时需要预编译：答案：１、总是使用不经常改动的大型代码体。
２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。
在这种情况下，可以将所有包含文件预编译为一个预编译头。
（2）char * const p char const * p const char *p 上述三个有什么区别？答案：char * const p; //常量指针，p的值不可以修改char const * p；//指向常量的指针，指向的常量值不可以改 const char *p； //和char const *p （3）char str1[] = "abc"; char str2[] = "abc"; const char str3[] = "abc"; const char str4[] = "abc"; const char *str5 = "abc"; const char *str6 = "abc"; char *str7 = "abc"; char *str8 = "abc"; cout < < ( str1 == str2 ) < < endl; cout < < ( str3 == str4 ) < < endl; cout < < ( str5 == str6 ) < < endl; cout < < ( str7 == str8 ) < < endl;结果是：0 0 1 1 str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。
（4）以下代码中的两个sizeof用法有问题吗？[C易] void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母 { for( size_t i=0;i <sizeof(str)/sizeof(str[0]); ++i ) if( 'a' <=str[i] && str[i] <='z' ) str[i] -= ('a'-'A' ); } char str[] = "aBcDe"; cout < < "str字符长度为: " < < sizeof(str)/sizeof(str[0]) < < endl; UpperCase( str ); cout < < str < < endl; 答案：函数内的sizeof有问题。
c语言数值交换方法
在C语言中，交换两个数值通常需要使用一个临时变量。
以下是一个基本的例子：c#include <stdio.h>int main() {int a = 5, b = 10, temp;printf("原始数值: a = %d, b = %d\n", a, b);temp = a;a = b;b = temp;printf("交换后的数值: a = %d, b = %d\n", a, b);return 0;}在这个例子中，我们首先定义了两个变量a和b，并分别赋予它们5和10。
然后，我们定义了一个临时变量temp，将a的值赋给它。
接着，我们将b的值赋给a，然后将temp的值（即原来a的值）赋给b。
这样就完成了两个数值的交换。
但是，如果你想在函数中交换两个变量的值，那么你不能直接交换，因为函数参数是按值传递的，这意味着如果你在函数内部改变参数的值，那么原始变量的值并不会改变。
所以，如果你需要在函数中交换两个变量的值，你需要将它们的引用传递给函数，或者你需要传递指针。
以下是一个使用引用的例子：c#include <stdio.h>void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;}int main() {int a = 5, b = 10;printf("原始数值: a = %d, b = %d\n", a, b);swap(&a, &b);printf("交换后的数值: a = %d, b = %d\n", a, b);return 0;}在这个例子中，我们定义了一个名为swap的函数，它接受两个指向int的指针作为参数。
在函数内部，我们使用指针来访问和修改原始变量的值。
在main函数中，我们首先将a和b的地址传递给swap函数，然后交换它们的值。
巨人网络游戏程序员面试题
软件工程师笔试试题笔试时间：三小时内姓名：余文瑛开始时间：08:10完成时间：11:10（解题前，请首先写设计思路。
）（请自行解答，一旦发现抄袭，笔试成绩取消。
）第一题：写一个函数，交换两个变量的值，不使用第三个变量。
如a=3,b=5,交换之后a=5,b=3;答：描述:不使用新的空间，那么只能使用原来的变量‘记忆’旧的数据，由void swap(int *a,int *b) //C++语言描述{*a=*a+*b;*b=*a-*b;*a=*a-*b;}第二题：编程求两个矩形的相交矩形分别输入两个空间中两个矩形的左上角坐标x,y，以及宽（width)高(height), 如果两个矩形有相交，输出相交的矩形左上角，右下角坐标,x1,y1,x2,y2例如：键盘输入：0,0,100,10020,20,100,40输出：20，20，100，60算法描述:我们将平面上的两个矩形分为左右两边，将左上角的横坐标较小的那个矩形看成’左边’矩形，较大的为右边矩形。
对于输入的rect1和rect2,如果rect2.p1.x 大于rect2.p1.x则交换他们的位置.我们用R1表示左边巨型，R2表示右边矩形那么他们的相对位置有4种情况:(1)R1右部上下两个顶点均//被包含在R2中(2)R2左部上下两个定点均被包含在R1中(3)R1右上方顶点被包含在右部矩形中，而右下角不在(4)R1的右下角顶点被R2包含，而右上角不在其中在(3)(4)种，还要分两种情况计算.#include <iostream>using namespace std;//为了保证安全性，一般将类的成员访问属性设置为private,通过相关的属性(函数进行访问)，但本例中//为了简便，将部分成员直接设置为public访问属性class Point //定义点类{public:int x,y;public:Point(){}Point(int a,int b){x=a;y=b;}};class Rect //矩形类{public:Point p1; //左上角点坐标int height; // 高int width;//长public:Rect(Point a,int w,int h){p1=a;height=h;width=w;}Rect(){}};class Intersect //处理相交情况类{private:Rect R1,R2; //2个矩形public:Point p1;bool b_inter;//指示是否相交bool b_include;//指示是否包含(约定：包含必相交)public:Intersect(Rect rect1,Rect rect2 ){R1=rect1;R2=rect2;b_inter=false;//指示两矩形是否相交，初始值为false,在构造函数中初始化b_include=false;}void slove() //求相交{if(R1.p1.x+R1.width>=R2.p1.x) //{include();if(!b_include)shuzhifangxiang();}else{swap(&R1,&R2); //使得rect1是"左边"图形include();if(!b_include)shuzhifangxiang();}}void swap(Rect *r1,Rect *r2) //矩形交换位置，目的是获得相对位置在左边的矩形为参照{Rect temp;temp=*r1;*r1=*r2;*r2=temp;}void include() //判断并求包含的相交{if((R2.p1.x>=R1.p1.x)&&(R2.p1.y>=R1.p1.y)&&((R2.p1.x+R2.width)<=(R1. p1.x+R1.width))&&((R2.p1.y+R2.height)<=(R1.p1.y+R1.height))){Point p11(R2.p1.x,R2.p1.y);Point p22(R2.p1.x+R2.width,R2.p1.y+R2.height);b_inter=true;b_include=true;p1=p11;p2=p22;cout<<"包含"<<endl;}}void shuzhifangxiang() //求非包含的相交{if(R1.p1.y>=R2.p1.y&&(R1.p1.y+R1.height)<=R2.p1.y+R2.height)//(1)R1右部上下两个顶点均//被包含在R2中{Point p11(R2.p1.x,R1.p1.y);Point p22(R1.p1.x+R1.width,R1.p1.y+R1.height);b_inter=true;p1=p11;p2=p22;cout<<"情况1"<<endl;}//(2)R2左部上下两个定点均被包含在R1中if((R1.p1.y<=R2.p1.y)&&((R1.p1.y+R1.height)>=(R2.p1.y+R2.height))){Point p11(R2.p1.x,R2.p1.y);Point p22(R1.p1.x+R1.width,R2.p1.y+R2.height);b_inter=true;p1=p11;p2=p22;cout<<"情况2"<<endl;}//(3)if((R1.p1.y<=(R2.p1.y+R2.height))&&(R1.p1.y>=R2.p1.y)&&((R1.p1.y+R1. height)>=(R2.p1.y+R2.height)))//R1右上方顶点被包含在右部矩形中，而右下角不在{//依然有两种情况//1只包含右侧矩形的1个端点//2包含右侧图形的2个端点if(R2.p1.x+R2.width>=R1.p1.x+R1.width){Point p11(R2.p1.x,R1.p1.y);Point p22(R1.p1.x+R1.height,R2.p1.y+R2.height);p1=p11;p2=p22;cout<<"情况3.1"<<endl;}else{Point p11(R2.p1.x,R1.p1.y);Point p22(R2.p1.x+R2.width,R2.p1.y+R2.height);p1=p11;p2=p22;cout<<"情况3.2"<<endl;}b_inter=true;}if(((R1.p1.y+R1.height)>=R2.p1.y)&&((R1.p1.y+R1.height)<=(R2.p1.y+R2.h eight))&&(R1.p1.y<=R2.p1.y))//R1的右下角顶点被R2包含，而右上角不在{ //依然有两种情况//1包含右侧矩形的两个端点//2至包含右侧图形的1个端点if(R1.p1.x+R1.width<=R2.p1.x+R2.width){Point p11(R2.p1.x,R2.p1.y);Point p22(R1.p1.x+R1.width,R1.p1.y+R1.height);p1=p11;p2=p22;cout<<"情况4.1"<<endl;}else{Point p11(R2.p1.x,R2.p1.y);Point p22(R2.p1.x+R2.width,R2.p1.y+R2.height);p1=p11;p2=p22;cout<<"情况4.2"<<endl;}b_inter=true;}}};int main(){//测试情况二//Point p1(0,0);//Point p2(20,20);//Rect Rect1(p1,100,100);//Rect Rect2(p2,100,40);//测试情况一，三//.....Intersect inter(Rect1,Rect2);inter.slove ();cout<<inter.p1 .x <<","<<inter.p1 .y <<endl;cout<<inter.p2 .x <<","<<inter.p2 .y <<endl;return 0;s}第三题：模拟实现乘法运算A*B = C，A和B最大值为9999. 要求输出如下1234* 121--------------123424681234= --------------14 9 3 1 4算法描述;(1)开辟两个数组，分别存储2个四位整数(注意在输入的时候123应当输入0123,即应该输入四位数)(2)用第二个乘数的个位数分别乘以第一个乘数的个位，十位，百位和千位，并处理进位问题(3)分别用第二个数的十位，百位，千位重复(2)的步骤(4)将乘法中间数组temp[4][8],竖直方向求和（并处理进位问题），然后该和的个位数即是最终答案的对应为数值(5)输出最终答案数组product[8];#include<iostream>#include<math.h>using namespace std;class Help{public:int a[4],b[4]; //两个数组，分别存储两个乘数int product[8]; //存储成绩int temp[4][8]; //存储中间乘法过程public:void cout_1array(int A[]) //输出一维数组{int i;for(i=0;i<4;i++)cout<<A[i];}void cout_2array(int A[][8]) //输出二维数组{int i,j;for(i=0;i<4;i++){for(j=0;j<8;j++){ cout<<A[i][j]<<" ";}cout<<endl;}}void cin_Aarray() //接受键盘输入，初始化一维数组{for( int i=0;i<4;i++)cin>>a[i];}void cin_Barray() //接受键盘输入，初始化一维数组{for( int i=0;i<4;i++)cin>>b[i];}void show_Multiplication() //模拟显示计算过程{int i,j,k=7,g,jinwei=0,l=0;for(i=3;i>=0;i--,k--,l++){ g=k;for(j=3;j>=0;j--,g--){temp[l][g]=(jinwei+a[j]*b[i])%10 ;//jinwei=(jinwei+a[j]*b[i])/10;}jinwei=0;}cout<<endl;}void Multiplication() //计算两数的乘积{show_Multiplication();int i,j,k,jinwei=0,sum;for(k=7,j=7;j>=0;j--,k--){sum=0;for(i=0;i<=3;i++){sum=sum+temp[i][j];}sum=sum+jinwei;product[k]=sum%10;jinwei=(jinwei+sum)/10;}}private:void init_2array() //将二维数组中的初始化为0 {for(int i=0;i<4;i++)for(int j=0;j<8;j++)temp[i][j]=0;}public:Help(){init_2array() ;//将二维数组中的初始化}};int main(){Help help;help.cin_Aarray ();help.cin_Barray ();help.cout_1array (help.a );cout<<"*";help.cout_1array (help.b );cout<<"="<<endl;//help.show_Multiplication ();help.Multiplication ();help.cout_2array (help.temp );cout<<endl;for(int i=0;i<8;i++)cout<<help.product [i];cout<<endl;}第四题：请设计一个KString类,让它具备如下特性:1) KString str1 = "Hello";2) KString str2 = str1;3) str += "world";在执行1）之后，str1 的内容是"Hello";在执行2）之后，str2 的内容是"Hello"; 但是str2内部未给"Hello"分配新空间；在执行3）之后，str2 的内容是"Helloworld", str1的内容是"Hello"而未改变；请下载者自己搞定问答题第五题:少年易学老难成，一寸光阴不可轻- 百度文库1、请问作完以上四题后，你对自已或对题目本身有如何的评价或体会。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
交换两个变量的值，不使用第三个变量的方法及实现：附录中有C/C++代码：通常我们的做法是（尤其是在学习阶段）：定义一个新的变量，借助它完成交换。
代码如下：int a,b;a=10; b=15;int t;t=a; a=b; b=t;这种算法易于理解，特别适合帮助初学者了解计算机程序的特点，是赋值语句的经典应用。
在实际软件开发当中，此算法简单明了，不会产生歧义，便于程序员之间的交流，一般情况下碰到交换变量值的问题，都应采用此算法（以下称为标准算法）。
上面的算法最大的缺点就是需要借助一个临时变量。
那么不借助临时变量可以实现交换吗？答案是肯定的！这里我们可以用以下几种算法来实现：1）算术运算；2）指针地址操作；3）位运算；4）栈实现。
1）算术运算int a,b;a=10;b=12;a=b-a; //a=2;b=12b=b-a; //a=2;b=10a=b+a; //a=12;b=10它的原理是：把a、b看做数轴上的点，围绕两点间的距离来进行计算。
具体过程：第一句“a=b-a”求出ab两点的距离，并且将其保存在a中；第二句“b=b-a”求出a到原点的距离（b到原点的距离与ab两点距离之差），并且将其保存在b中；第三句“a=b+a”求出b到原点的距离（a到原点距离与ab两点距离之和），并且将其保存在a中。
完成交换。
此算法与标准算法相比，多了三个计算的过程，但是没有借助临时变量。
（以下称为算术算法）除了使用加、减法外，还可以使用乘、除法实现，实现代码如下：//if a=10;b=12;a=a*b; //a=120;b=12b=a/b; //a=120;b=10a=a/b; //a=12;b=10缺点：是只能用于数字类型，字符串之类的就不可以了。
a+b有可能溢出(超出int的范围)，溢出是相对的，+了溢出了，-回来不就好了，所以溢出不溢出没关系，就是不安全。
2）指针地址操作因为对地址的操作实际上进行的是整数运算，比如：两个地址相减得到一个整数，表示两个变量在内存中的储存位置隔了多少个字节；地址和一个整数相加即“a+10”表示以a为基地址的在a后10个a类数据单元的地址。
所以理论上可以通过和算术算法类似的运算来完成地址的交换，从而达到交换变量的目的。
即：int *a,*b; //假设*a=new int(10);*b=new int(20); //&a=0x00001000h,&b=0x00001200ha=(int*)(b-a); //&a=0x00000200h,&b=0x00001200hb=(int*)(b-a); //&a=0x00000200h,&b=0x00001000ha=(int*)(b+int(a)); //&a=0x00001200h,&b=0x00001000h通过以上运算a、b的地址真的已经完成了交换，且a指向了原先b指向的值，b指向原先a指向的值了吗？上面的代码可以通过编译，但是执行结果却令人匪夷所思！原因何在？首先必须了解，操作系统把内存分为几个区域：系统代码/数据区、应用程序代码/数据区、堆栈区、全局数据区等等。
在编译源程序时，常量、全局变量等都放入全局数据区，局部变量、动态变量则放入堆栈区。
这样当算法执行到“a=(int*)(b-a)”时，a的值并不是0x00000200h，而是要加上变量a所在内存区的基地址，实际的结果是：0x008f0200h，其中0x008f即为基地址，0200即为a在该内存区的位移。
它是由编译器自动添加的。
因此导致以后的地址计算均不正确，使得a,b指向所在区的其他内存单元。
再次，地址运算不能出现负数，即当a的地址大于b的地址时，b-a<0，系统自动采用补码的形式表示负的位移，由此会产生错误，导致与前面同样的结果。
有办法解决吗？当然！以下是改进的算法：if(a<b){a=(int*)(b-a);b=(int*)(b-(int(a)&0x0000ffff));a=(int*)(b+(int(a)&0x0000ffff));}else{b=(int*)(a-b);a=(int*)(a-(int(b)&0x0000ffff));b=(int*)(a+(int(b)&0x0000ffff));}算法做的最大改进就是采用位运算中的与运算“int(a)&0x0000ffff”，因为地址中高16位为段地址，后16位为位移地址，将它和0x0000ffff进行与运算后，段地址被屏蔽，只保留位移地址。
这样就原始算法吻合，从而得到正确的结果。
此算法同样没有使用第三变量就完成了值的交换，与算术算法比较它显得不好理解，但是它有它的优点即在交换很大的数据类型时，它的执行速度比算术算法快。
因为它交换的时地址，而变量值在内存中是没有移动过的。
（以下称为地址算法）3）位运算int a=10,b=12; //a=1010^b=1100;a=a^b; //a=0110^b=1100;b=a^b; //a=0110^b=1010;a=a^b; //a=1100=12;b=1010;此算法能够实现是由异或运算的特点决定的，通过异或运算能够使数据中的某些位翻转，其他位不变。
这就意味着任意一个数与任意一个给定的值连续异或两次，值不变。
4）栈实现。
不多解释了，栈和相关函数定义省去。
int exchange(int x,int y){stack S;push(S,x);push(S,y);x=pop(S);y=pop(S);}以上算法均实现了不借助其他变量来完成两个变量值的交换，相比较而言算术算法和位算法计算量相当，地址算法中计算较复杂，却可以很轻松的实现大类型（比如自定义的类或结构）的交换，而前两种只能进行整形数据的交换（理论上重载“^”运算符，也可以实现任意结构的交换）。
也有一些资料上采用一句赋值语句实现交换操作，典型的有以下两种：（1） a = a + b - (b = a);（2） b = a + (a = b)*0;但是这两条语句在VS2010上测试，结果为：交换后（1）中，a、b都是a的值，而（2）中，a、b 都是b的值，显然不是我们想要的结果。
对以上结果应该这样理解，（1）中首先执行b=a，此时，a、b 的值都是a，那么再向下执行就相当于，a=a+a-a；（2）也一亲，首先执行a=b;如果再使用a的值应该就是b了，因此再执行就是b=b+(a=b)*0;之所以存在这种方法有可能是从处理器处理的的角度考虑的，例如(1)中，将a、b、（b=a）同时放入寄存器中，这样有可能得到正确结果，但是实际执行过程中，当执行完(b=a)后，立即更新了寄存器的值，因此才不能达到应有目的。
介绍这几种算法并不是要应用到实践当中，而是为了探讨技术，展示程序设计的魅力。
从中可以看出，数学中的小技巧对程序设计而言具有相当的影响力，运用得当会有意想不到的神奇效果。
而从实际的软件开发看，标准算法无疑是最好的，能够解决任意类型的交换问题。
附录1：所有方法的C语言代码由于C标准库中没有栈的函数，因此需要自己写压栈、出栈函数（其实栈就相当于是FILO）。
但是C++中有stack的类。
#include <stdio.h>#include<malloc.h>void MethodA(int a, int b);void MethodB(int a, int b);void MethodC(int a, int b);void MethodD(int *a, int *b);void MethodE(int a, int b);void main(){int x,y;printf("Exchange the two variables,without a third variable!\n");printf("By:zzm\n");MethodA(1,2);MethodB(2,3);MethodC(3,4);x=4;y=5;MethodD(&x,&y);MethodE(5,6);}void MethodA(int a, int b){printf("%s:\n",__FUNCTION__);printf("Before exchange: a = %d, b = %d\n",a,b);//if a=10;b=12;a=b-a;//a=2;b=12b=b-a;//a=2;b=10a=b+a;//a=12;b=10printf("After exchange: a = %d, b = %d\n",a,b);}void MethodB(int a, int b){printf("%s:\n",__FUNCTION__);printf("Before exchange: a = %d, b = %d\n",a,b);//if a=10;b=12;a=a*b;//a=120;b=12b=a/b;//a=120;b=10a=a/b;//a=12;b=10printf("After exchange: a = %d, b = %d\n",a,b);}void MethodC(int a, int b){printf("%s:\n",__FUNCTION__);printf("Before exchange: a = %d, b = %d\n",a,b);// if a=10,b=12; a=1010^b=1100;a=a^b;//a=0110^b=1100;b=a^b;//a=0110^b=1010;a=a^b;//a=1100=12;b=1010;printf("After exchange: a = %d, b = %d\n",a,b);}void MethodD(int *a, int *b){printf("%s:\n",__FUNCTION__);printf("Before exchange: *a = %d, *b = %d\n",*a,*b);if(a<b)//the address must >0{//&a=0x00001000h,&b=0x00001200h a=(int*)(b-a);//&a=0x00000200h,&b=0x00001200hb=(int*)(b-((int)a &0x0000ffff));//&a=0x00000200h,&b=0x00001000ha=(int*)(b+((int)a &0x0000ffff));//&a=0x00001200h,&b=0x00001000h }else{b=(int*)(a-b);a=(int*)(a-((int)b &0x0000ffff));b=(int*)(a+((int)b &0x0000ffff));}printf("After exchange: *a = %d, *b = %d\n",*a,*b);//zzm 地址作差，值为:相差字节数/指针类型的字节数//地址加1，地址的变化:原地址+指针类型占的空间}typedef struct Node{int data;struct Node *pNext;}NODE;//栈可以想象为一个箱子，放东西（进栈）是从栈底放起往上添加，拿出来（出栈）是从上面先来。