C和指针看书随笔
1.跳出循环的语句不只有break；还有使用return语句在某些情况下也适用；
2.continue语句对于switch语句无效，但是如果switch语句位于循环内，continue是会结束当前循环的。
10-28
1.% 运算符两边都要是 整型。
2.>> << 操作符的操作数都要是整型。
3. 如下的方法可以判断value的最低位是否为1
if(value % 2 != 0)
4.getchar（）返回的是整型，所以while（（ch = getchar（）） ！= EOF）在某些情况下回出问题，ch如果是字符型，数据会截断，导致判断出错。
5." - "，减号在C语言中代表产生操作数的负值。
11/1
1.b=++a和b=a++在进行赋值的时候，实际是把a值的拷贝赋值给b，而不是，++a和a++的结果是a值的拷贝，所以++a=b是不成立的，拷贝值不能被赋值。
2.关系操作符： > >= < <= != ==
这几个操作符返回值都是整型，而不是布尔值，C语言没有布尔值。
3.C语言在if语句里进行赋值是合法的，比如if（x = 4），有时候我们是要写if（x == 4），但是前面那样写也没有问题。
4.条件操作符优先级非常低，expression1？expression2：expression3
5.逗号表达式的值时最后一个值，expression1，expression2，expression3，。。。expressionN。有以下用法可以参考：
while(a > 0)
{
a=b;
b=c;
}
可以换成：
while（a = b, b=c,a>0）
{
;
}
- 左值和右值，在赋值号左边称为左值，等号右边称为右值，左值一般来说需要标识一个特定的位置，用于存储值，而右值可以只是一个值，比如b=a+25；变量b标识了b的位置，故可以做左值，返回来a+25 = b；a+25没有标识存储的位置，就不能当左值。
11/18
1.将一个变量按照二进制进行逆序排列，然后输出，比如000 1000；转换后变成0001 0000；代码如下：
#include "stdio.h"
unsigned int reverse_bits(unsigned int value);
int main()
{
unsigned int value =40;
reverse_bits(value);
}
unsigned int reverse_bits(unsigned int value)
{
int size;
int i =0;
char str[32] = {0};
char temp;
size = sizeof(value) * 8;
while(i<size)
{
str[i++] = (value&(1<<i))>>i;
}
for(i=0;i<size/2;i++)
{
temp = str[i];
str[i] = str[size -i -1];
str[size -i -1] = temp;
}
for(i=0;i<size;i++)
{
if(str[i]==1)
{
printf("tt");
value |=1<<i;
}
else
{
value &=~(1<<i);
}
}
printf("%d\n",value);
}
2.静态变量不初始化系统一般默认0；
3.计算字符串长度的写法：
while(*string++ != '\0')
{
len++;
}
11/23
1.sizeof()计算字符串是包括‘\0’的，strlen不计算’\0’，比如一个字符串，sizeof的结果是11.strlen的结果是10；
11/24
1.寻找质数的方法：先找到第一个质数，然后将后面所有是这个质数的倍数剔除，然后找到第二个质数，接着将是这个质数的倍数的数剔除，以此类推。比如第一个质数是2，后面的2的倍数都不是质数。
2.全局变量和静态全局变量的存储方式没有什么不同，但是作用域不同，全局变量的作用域是整个源程序，静态全局变量的作用域是一个源文件。
3.今天代码，含第七章和第六章：
#include <stdio.h>
void find_prime_number();
void print_str(int *strnumber);
int hermit(int n,int x);
int gcd(int m, int n);
int main() {
int strtemp[101] = {0};
int *p = &strtemp[0];
int i=0;
i=gcd(9,9);
printf("%d\n",i);
return 0;
}
void find_prime_number(int *strnumber)
{
int temp=2;
int i =1;
while(*strnumber != -1)
{
temp=2;
i =1;
if(*strnumber <=1)
{
*strnumber = 0;
strnumber++;
continue ;
}
else
{
while((temp < *strnumber) && (*strnumber != 0))
{
if(*strnumber % temp == 0)
{
*strnumber = 0;
break;
}
temp++;
}
while(*(strnumber +i) != -1)
{
if(*(strnumber + i) % (*strnumber) == 0)
{
*(strnumber + i) = 0;
}
i++;
}
}
strnumber++;
}
}
void print_str(int *strnumber)
{
int i =0;
for(i=0;i<100;i++)
{
if(i%10 ==0)
{
printf("\n");
}
printf("%d ", *strnumber++);
}
}
int hermit(int n,int x)
{
if(n <= 0)
return 1;
else if(n == 1)
return 2 * x;
else if(n >= 2)
{
return 2*x*hermit(n-1,x) - 2*(n-1)*hermit(n-2,x);
}
}
int gcd(int m, int n)
{
int i = 0;
if(m<=0 || n<=0)
return 0;
if(m%n == 0)
return n;
else
return gcd(n,m%n);
}
11/25
第七章习题：
#include <stdio.h>
#include <stdarg.h>
int max_list(int n_values,...);
float average(int n_value,...);
int my_sprintf(const char *format,...);
int main() {
int temp;
float av;
av = average(3,200,24,100);
temp = max_list(100,200);
//rintf("%f",av);
//print_integer();
my_sprintf("temp:%f\n",123.2342);
return 0;
}
void find_max(int n_value,...)
{
va_list var_arg;
}
int max_list(int n_values,...)
{
va_list var_arg;
int max = 0;
int tmp;
va_start(var_arg,n_values);
while((tmp = va_arg(var_arg,int )) >= 0)
{
max = (tmp > max )?tmp:max;
}
va_end(var_arg);
return max;
}
float average(int n_value,...)
{
va_list var_arg;
int i=0;
float avg=0;
int n_values = 0;
va_start(var_arg,n_value);
for(;i<n_value;i++)
{
avg +=va_arg(var_arg,int );
}
va_end(var_arg);
return avg/n_value;
}
int my_sprintf(const char *format,...)
{
va_list var_arg;
const char *p;
int ival;
double dval;
const char *s;
char buff[100] = {0};
int i =0;
if(format == NULL)
{
return -1;
}
va_start(var_arg,format);
for(p = format; *p; ++p)
{
if(*p != '%')
{
putchar(*p);
continue;
}
switch(*++p)
{
case 'd':
ival = va_arg(var_arg,int);
sprintf( buff, "%d", ival);
i=0;
while(buff[i]!=0)
{
putchar(buff[i++]);;
}
//buff[i] = '\0';
break;
case 'f':
dval = va_arg(var_arg,double);
sprintf( buff, "%f", dval);
i=0;
while(buff[i]!=0)
{
putchar(buff[i++]);;
}
//buff[i] = '\0';
break;
}
}
}
char str_number[20] [10]= {"one", "two", "three",
"four", "five", "six","seven ",
"eight", "nine","ten",
"eleven","twelve ","thirteen",
"fourteen","fifteen","sixteen",
"seventeen", "eighteen", "nineteen",
"twenty",
};
char str_ten[7][7] = {"thirty", "forty","fifty","sixty","seventy",
"eighty", "ninety",
};
char str_100[2][10] = {"hundred", "thousand"，"million"};
void written_amount(unsigned int amount, char *buff)
{
char printf_str[100]= {0};
char num_bit[10] = {'\0'};
int i;
int bit =0;
unsigned int temp;
int num;
for(i=0;amount!=0;i++)
{
temp = amount%10;
if(amount%10>0)
{
num_bit[i]=amount%10;
amount /=10;
}
}
bit = --i;
while(--i>=0)
{
if(i == 6 && bit >= 6)
{
strcat(printf_str,str_number[num_bit[i]]);
strcat(printf_str,str_100[2]);
}
else if(i>=3 && (bit >=3 && bit <=5))
{
if(i == 5)
{
strcat(printf_str,str_number[num_bit[i]]);
strcat(printf_str,str_100[0]);
}
else if( i == 4)
{
if(num_bit[i] >2 )
{
strcat(printf_str,str_ten[num_bit[i]]);
}
else
{
}
strcat(printf_str,str_100[0]);
}
}
}
if(amount<=20)
{
printf("%s",str_number[amount -1]);
}
else
{
if(amount> 1000000 )
{
strcat(printf_str,str_number[amount/1000000 -1]);
strcat(printf_str,str_100[2]);
//sprintf(printf_str, "%s %s", str_number[amount/1000000 -1], str_100[2]);
}
if(amount/1000 <= 999)
{
strcat(printf_str,str_number[amount/1000 -1]);
}
if(amount/10 <=9)
{
printf("%s %s",str_number[amount/10], str_ten[amount%10 - 3]);
}
else if(amount/100 <=9)
{
printf("%s %s %s",str_ten[amount/100], str_100[0], );
}
}
}
11/30
1.不用为了细微的效率差别而牺牲可度性。
2.数组不初始化后默认值一般是0。
3.编译器对数组下标是从左到右进行计算的，但是str[2,3]在编译器中也是有效的，他和str[3是等效的，因为逗号表达式都是从先计算左值，然后丢弃，最后计算右值，结果为右值。
4.数组下标的引用高于间接访问。
12/6
1.C语言的数组下标可以是负数，比如 a [-1] = *(a -1)，因为下标引用和其实会换成指针操作。
2.二维数组的下标代表行和列,a[2][4];代表两行四列。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
