MS(一)

系统管理员 2022-08-05 08:49 129阅读 0赞

//1. 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
    #define SECONDS_PER_YEAR (365*24*60*60)UL
    #define SECONDS_PER_YEAR ((unsigned long)(365*24*60*60))
    
    //2. 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。
    #define MIN(a,b)   ( (a) <= (b) ? (a) : (b) )
    #define MIN(A,B)  ( (A) <= (B)?  (A) : (B) ) 
    
    
    5. 用变量a给出下面的定义 
    a) 一个整型数（An integer） 
    int a; // An integer 
    
    b) 一个指向整型数的指针（A pointer to an integer） 
    int *a;// A pointer to an integer 
    
    c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer） 
    int **a;//A pointer to a pointer to an integer
    
    d) 一个有10个整型数的数组（An array of 10 integers） 
    int a[10];//An array of 10 integers
    
    e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers） 
    int *a[10];//An array of 10 pointers to integers
    
    f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers） 
    int (*a)[10];//A pointer to an array of 10 integers
    
    g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数
    （A pointer to a function that takes an integer as an argument and returns an integer） 
    int (*a)(int); //A pointer to a function that takes an integer as an argument and returns an integer
    
    h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数
    （ An array of ten pointers to functions that take an integer argument and return an integer ）
    int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer 
    
    
    
    //strcpy 
    char *mystrcpy(char *dest, const char *src )
    {
    	//assert ((dest != NULL)&&(src != NULL))
    	if( (src != NULL) && (dest != NULL))
    	{
    		char *address = dest;
    		while ( (*dest++ = *src++) != '\0' );
    		
    	}else
    	{
    		return -1;
    	}
    	
    	return address;
    }

![20150911160757634][]

![20150911160852089][]

![20150911160902217][]

![20150911160912749][]

![20150911160924851][]

![20150911161551955][]

![20150911161610791][]

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

下面的一段程序有什么错误：

swap( int* p1,int* p2 )
    {
    　int *p;
    　*p = *p1;
    　*p1 = *p2;
    　*p2 = *p;
    }

在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。在vc++中debug运行时提示错误“access violation”。该程序应该改为：

swap( int* p1,int* p2 )
    {
    　int p;
    　p = *p1;
    　*p1 = *p2;
    　*p2 = p;
    }

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

#include <stdio.h>
    #include <iostream>
    using namespace std;
    
    #define uchar  unsigned char
    
    void func ( char str[100] )
    {
    	//int n = sizeof( str );
    	cout << sizeof( str ) << endl;
    }
    
    int main(void)
    {
    
    	int a = 5, b = 7, c; 
    	c = a+++b;
    	printf("a:%d  b:%d  c:%d\n", a, b, c);
    
    	void *p = malloc( 100 );
    	cout << sizeof ( p ) << endl;
    
    	char str1[100];
    	cout << sizeof( str1 ) << endl;
    	func(str1);
    
    	system("pause");
    }
    
    /*
    a:6  b:7  c:12
    4
    100
    4
    请按任意键继续. . .
    
    */

![20150916104906393][]

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

写一个“标准”宏min，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？  
least = min(\*p++, b);   
  
  
解答：  
\#define min(a,b) ((a) <= (b) ? (a) : (b))   
min(\*p++, b)会产生宏的副作用  
(\*p++) <= (b)?(\*p++):(b)  
(\*p++) <= (b)?执行完，\*p的值已经变化了，返回的\*p值是上一个指针指的下一个数值。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

为什么标准头文件都有类似以下的结构？   
\#ifndef \_\_incvxworksh  
\#define \_\_incvxworksh   
\#ifdef \_\_cplusplus  
extern "c" \{  
\#endif   
/\*...\*/   
\#ifdef \_\_cplusplus  
\}  
\#endif   
\#endif /\* \_\_incvxworksh \*/   
  
解答：  
头文件中的编译宏  
\#ifndef　\_\_incvxworksh  
\#define　\_\_incvxworksh  
\#endif   
的作用是防止被重复引用。  
为了实现c和c++的混合编程，c++提供了c连接交换指定符号extern "c"来解决名字匹配问题，函数声明前加上extern "c"后，则编译器就会按照c语言的方式将该函数编译为\_foo，这样c语言中就可以调用c++的函数了。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

编写一个函数，作用是把一个char组成的字符串循环右移n个。  
比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”   
  
  
//pstr是指向以'\\0'结尾的字符串的指针  
//steps是要求移动的n  
  
void loopmove ( char \* pstr, int steps )  
\{  
　//请填充...  
 \}

<pre name="code" class="cpp">#include <stdio.h>
    #include <iostream>
    using namespace std;
    
    /*
    编写一个函数，作用是把一个char组成的字符串循环右移n个。
    比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh” 
    
    //pstr是指向以'\0'结尾的字符串的指针
    //steps是要求移动的n
    
    void loopmove ( char * pstr, int steps )
    {
    　//请填充...
     } 
    */
    
    void loop_move(char *pstr, int steps)
    {
    	steps = steps % strlen(pstr);//当移动的steps大于字符的长度时，对其长度求模即可
    
    	char temp[1024] = { 0 };
    
    	int str_r = strlen(pstr) - steps; 
    	//cout << str_r << endl;
    
    	strcpy(temp, pstr + str_r);//abcdefghi 要移动的字符串的后半部分 hi
    	strcpy(temp + steps , pstr);//hiabcdefghi
    	temp[strlen(pstr)] = '\0';//hiabcdefg
    
    	//strncpy(temp+steps, pstr, (strlen(pstr)- steps) ); //26,27行等价于该行
    	strcpy(pstr,temp);
    
    }
    
    int main(void)
    {
    
    	char s[] = "abcdefghi";
    	cout << s << endl;
    	loop_move(s,2); //loop_move(s,11);
    	cout << s << endl;
    
    	system("pause");
    }
    
    /*
    abcdefghi
    hiabcdefg
    请按任意键继续. . .
    */

steps = steps % strlen(pstr);//当移动的steps大于字符的长度时，对其长度求模即可

![20150916113502805][]

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

1) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

2) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。举一个例子，比如：

数字0x12 34 56 78在内存中的表示形式为：

1)大端模式：

低地址 -----------------> 高地址

0x12  |  0x34  |  0x56  |  0x78

2)小端模式：

低地址 ------------------> 高地址

0x78  |  0x56  |  0x34  |  0x12

/***************************************
    1) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
    2) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
    举一个例子，比如数字0x12 34 56 78在内存中的表示形式为：
    
    1)大端模式：
    低地址 -----------------> 高地址
    0x12  |  0x34  |  0x56  |  0x78
    
    2)小端模式：
    低地址 ------------------> 高地址
    0x78  |  0x56  |  0x34  |  0x12
    
    
    嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。
    采用Little-endian模式的CPU对操作数的存放方式是从低字节到高字节，
    而Big-endian模式对操作数的存放方式是从高字节到低字节。
    例如
    16bit宽的数0x1234在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
    
    	内存地址
    	0x4000
    	0x4001
    
    	存放内容
    	0x34
    	0x12
    	而在Big-endian模式CPU内存中的存放方式则为：
    
    	内存地址
    	0x4000
    	0x4001
    
    	存放内容
    	0x12
    	0x34
    	32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
    
    	内存地址
    	0x4000
    	0x4001
    	0x4002
    	0x4003
    
    	存放内容
    	0x78
    	0x56
    	0x34
    	0x12
    	而在Big-endian模式CPU内存中的存放方式则为：
    
    	内存地址
    	0x4000
    	0x4001
    	0x4002
    	0x4003
    
    	存放内容
    	0x12
    	0x34
    	0x56
    	0x78
    
    
    联合体union的存放顺序是所有成员都从低地址开始存放，利用该特性，
    轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写
    
    	*****************************************/
    
    
    #include <stdio.h>
    #include <iostream>
    using namespace std;
    
    
    //请写一个c函数，若处理器是big_endian的，则返回0；若是little_endian的，则返回1
    int checkCPU()
    {
    	short a = 0x1234; //short两个字节，char 一个字节
    	char *p = (char *)&a;
    	if (p[0] == 0x12) //if (*p == 0x12)
    	{
    		cout << "big_endian " << endl;
    		return 0; // big endian
    	}
    	else
    	{
    		cout << "little_endian " << endl;
    		return 1; //little_endian
    	}
    }
    
    
    //写一个C函数，若处理器是Big-endian的，则返回0；若是Little-endian的，则返回1
    //union型数据所占的空间等于其最大的成员所占的空间，
    //对union型成员的存取都是相对于该联合体基地址的偏移量为0处开始
    //即，联合体的访问不论对哪个变量的存取都是从union的首地址位置开始。
    int checkSystem()   
    {  
    	union check  
    	{  
    		int i;  
    		char ch;  
    	}c;  
    	c.i=1;  
    	return (c.ch==1);  
    }  
    
    
    int main(void)
    {
    	int cpu = checkCPU();
    	cout << cpu << endl;
    	system("pause");
    
    	return 0;
    }
    
    //little_endian
    //1
    //请按任意键继续. . .

[判断系统大小端方法分析与总结][Link 1]  [点击打开链接][Link 1] （转）

# **问题** ：如何用程序确认当前系统的存储模式(大端还是小端)？写一个C函数，若处理器是Big-endian的，则返回0；若是Little-endian的，则返回1。      **情况1：利用数组类型**  \#include <cstdio>    **int** checkSystem()    \{        **char** s\[\]="1000";        **return** (s\[0\]=='1');    \}    **int** main()    \{        checkSystem()==1 ? printf("Little-endian/n") : printf("Big-endian/n");        **return** 0;    \}    **情况2：利用位移运算**  **int** i = 1;    **if**(1>>32 == 0)          cout<<"小端模式"<<endl;    **else**          cout<<" 大端模式"<<endl;       上述方法正确吗？要理解为什么不正确？     因为不要在数值上做文章，而大小端是严格与内存挂钩的东西。如果int a=1; 那么a&1==1一定成立，因为这是从数值角度运算的，已经给用户屏蔽掉了大小端的问题。一定要int a=1; \*((char\*)(&a)) == 1 ，这样判断才有效。      下面总结一些有效的方法。      **方法1：利用union类型 —— 可以利用union类型数据的特点：所有成员的起始地址一致。**      \#include <cstdio>    **int** checkSystem()    \{        **union** check        \{            **int** i;            **char** ch;        \}c;        c.i=1;        **return** (c.ch==1);    \}    **int** main()    \{        checkSystem()==1 ? printf("Little-endian/n") : printf("Big-endian/n");        **return** 0;    \}       **方法2：对int强制类型转换**  \#include<stdio.h>    \#include<stdlib.h>    **int** main()    \{        **int** i = 1;        (\*(**char** \*)&i == 1) ? printf("Little-endian/n") : printf("Big-endian/n");        system("pause");        **return** 0;    \}       **方法3：使用union和宏定义**  \#include<stdio.h>    \#include<stdlib.h>    **static** **union**    \{        **char** a\[4\];        unsigned **long** ul;    \}endian = \{ \{ 'L', '?', '?', 'B'\}\};    \#define ENDIAN ((char)endian.ul)        **int** main()    \{        printf("%c/n", ENDIAN);        system("pause");        **return** 0;    \}       补充：    大小端模式对union类型数据的影响。  \#include <cstdio>    **union**    \{        **int** i;        **char** a\[2\];    \}\*p, u;    **int** main()    \{        p=&u;        p->a\[0\]=0x39;        p->a\[1\]=0x38;        printf("%x/n",p->i);// 3839 (hex.)        printf("%d/n",p->i);// 111000 00111001=14393 (decimal)        **return** 0;    \}       分析如下图所示：   高地址        低地址   —— —— —— ——   int   0   |   0   |  56  |  57       —— —— —— ——                  —— ——   char                   56  |   57                  —— ——         这里需要考虑存储模式：大端模式和小端模式。   大端模式(Big-endian)：数据的低字节存放在高地址中。   小端模式(Little-endian)：数据的低字节存放在低地址中。   union型数据所占的空间等于其最大的成员所占的空间，对union型成员的存取都是相对于该联合体基地址的偏移量为0处开始，即，联合体的访问不论对哪个变量的存取都是从union的首地址位置开始。因此，上面程序输出的结果就显而易见了。      #

[20150911160757634]: /images/20220731/8f9e61cd9a10407bbd9e9dd5d9796e06.png
[20150911160852089]: /images/20220731/242aa847bb8a45ecadeac06181799b3c.png
[20150911160902217]: /images/20220731/07893546a2354d9abbf04dd7569b1367.png
[20150911160912749]: /images/20220731/cd2a0d6f4c1b499ebc9980c88488573b.png
[20150911160924851]: /images/20220731/8c7a4ab81984474ea9f981e12e4d5bab.png
[20150911161551955]: /images/20220731/2b426095bc5f4639852fb640aa6ac942.png
[20150911161610791]: /images/20220731/a0d064f214be4d949789d73f04639a6c.png
[20150916104906393]: /images/20220731/9c349825630a4bef9ddda15ec77a7685.png
[20150916113502805]: /images/20220731/837cf5adc98444c8a9b35a8e71f656f5.png
[Link 1]: http://blog.csdn.net/delphiwcdj/article/details/6234383