C++博客-技术心得地

C 声明规则

海涛 — Tue, 13 Apr 2010 08:07:00 GMT

1. 取最左边标识符
2. 优先级从高到低：
      a. 标识符被括起来的部分
      b. 后缀操作符：()表示函数；[]表示数组
      c. 前缀操作符：*表示指针
3. const/volatile+类型说明符
    *+const/volatile

海涛 2010-04-13 16:07 发表评论

GCC AND GDB

海涛 — Sun, 11 Apr 2010 15:26:00 GMT

GCC:
1. -include stdlib.h
2. -c sourcename: only compile
3. -o objectname
4. -g sourcename: generate debug info
5. -ansi
6. -w: close all warning
7. -S: generate assembly lang

GDB:
1. break
2. watch
3. catch
4. clear / delete / disable / enable
5. continue / c
6. next / n
7. step / s
8. finish
9. stop / nostop
10. print / p
11. backtrace / bt : print stack info
12. fram / f :
13. up / down
14. info frame : print detailed stack info
15. info args : print current func's para name and value
16. info locals : print current func's local name and value
17. info catch : print current func's exception
18. list / l (set listsize 10)
19. search
20. examine / x : x /3uh 0x54320

海涛 2010-04-11 23:26 发表评论

Linux 命令技巧

海涛 — Fri, 09 Apr 2010 13:41:00 GMT

1. 列出目录:
ls -d */
ls -l|grep ^d

海涛 2010-04-09 21:41 发表评论

Debian Console 设置

海涛 — Thu, 08 Apr 2010 14:28:00 GMT

1. X-Windows / Console 切换命令:
Ctrl+Alt+Shift+F2, Alt+F7

2. Console 设置分辨率:
/boot/grub/menu.list : kernel line: vga=0x341

海涛 2010-04-08 22:28 发表评论

MySQL使用备忘

海涛 — Mon, 08 Mar 2010 16:18:00 GMT

1. 安装

2. 配置

3. 数据库操作

show databases;
create database mydatabase;
use mydatabase

4. 数据表操作

show tables;
create table mytable(column1 varchar(20), column2 char(1), column3 date, column4 date);
describe mytable;
load data local infile '/path/table.txt' into table mytable;
load data local infile '/path/table.txt' into table mytable
->lines terminated by '\r\n';
insert into mytable values('value1','v2','2000-01-01',NULL);

海涛 2010-03-09 00:18 发表评论

合并二个有序数组

海涛 — Wed, 24 Feb 2010 14:48:00 GMT

#include "stdio.h"

void merge(int la[], int lal, int lb[], int lbl, int *lc);

void main( void )
{
    int i = 0;
    int la[] = {2, 4, 6, 8, 10};
    int lb[] = {1, 3, 5, 7, 9};
    int lc[10] = {0};

    merge(la, 5, lb, 5, &lc);

    for(i = 0; i<10; i++)
    {
        printf("\n%d",lc[i]);
    }
}

void merge(int la[], int lal, int lb[], int lbl, int *lc)
{
    int i = 0;
    int j = 0;
    int k = 0;

    while(i < lal && j < lbl)
    {
        lc[k++] = la[i] < lb[j] ? la[i++] : lb[j++];
    }

    while(i < lal)
    {
        lc[k++] = la[i++];
    }
    while(j < lbl)
    {
        lc[k++] = lb[j++];
    }
}

海涛 2010-02-24 22:48 发表评论

[POINTERS ON C] 第十章结构和联合

海涛 — Thu, 07 Jan 2010 14:42:00 GMT

1. 聚合类型

结构和联合
结构 : 标量类型(内置类型)
struct tag { member-list } var-list;

下面是2个不同的结构:

struct{
    int   a;
    char  b;
    float c;
} x;

struct{
    int   a;
    char  b;
    float c;
} y;

typedef 用法:

typedef struct MyStruct_Tag {
    int    a;
    char   b;
    float  c;
} MyStruct

直接访问 : 结构名.成员名
间接访问 : 结构指针->成员名

不完整声明 : 类似函数声明

struct B;

struct A {
struct B *partner;
}

struct B {
struct A *partner;
}

初始化 :

typedef struct {
    int    a;
    char   b;
    float  c;
} Simple;

struct INIT_EX {
    int    a;
    short  b[6];
    Simple c;
} x = { 10, {1,2,3,4,5,6}, {12, 'x', 6.9} };

2. 结构的存储分配

满足边界对齐要求:
结构的起始存储位置必须是结构中边界要求最严格数据类型所要求的位置
结构的成员存储位置必须满足各自的存储要求

求偏移量函数:
offsetof ( type, member ); //stddef.h

3. 作为函数参数

值 : 结构的一份拷贝
指针 : 地址的一份拷贝

4. 位段

struct CHAR {
    unsigned  ch      : 7;
    unsigned  font    : 6;
    unsigned  size    : 13;
}

5. 联合

所有成员引用的是内存中的相同位置
长度是最长成员的长度

初始化：必须是联合第一个成员的类型

union {
    int    a;
    float  b;
    char   c[4];
} x = { 6 };

海涛 2010-01-07 22:42 发表评论

[POINTERS ON C] 第九章字符串、字符和字节

海涛 — Mon, 04 Jan 2010 17:32:00 GMT

1. 字符串

包括零个或多个字符
以 0 即 '\0'字节结尾
字符串长度不包括 NULL
包括在头文件 string.h 中

2. strlen

size_t
strlen( char const *string)
{
    int length;
    for( length = 0; *string++ != '\0'; length++ )
    return length;
}

注意事项: 返回值为无符号整数. 禁止使用 if( strlen(x) - strlen(y) >= 0 )...

3. 不受限制的字符串函数

使用这些函数时, 程序员必须保证结果字符串不会溢出这块内存

char *strcpy( char *dst, char const *src ); //dst将会被修改, 不能使用字符串常量; dst, src不能重叠
char *strcat( char *dst, char const *src ); //dst不能为NULL; dst, src不能重叠
char *strcmp( char const *s1, char const *s2 ); //

4. 长度受限的字符串函数

char *strncpy( char *dst, char const *src, size_t len ); //strlen(src) > len, dst将用NUL填充到len长度, 但 strlen(dst) 不变
char *strncat( char *dst, char const *src, size_t len ); //总是在结果字符串后面添加NUL字节, 但 strlen(dst) 不变
char *strncmp( char const *s1, char const *s2, size_t len ); //

5. 字符串查找

char *strchr( char const *str, int ch ); //查找ch第一次(最左边)出现位置
char *strrchr( char const *str, int ch ); //查找ch最后一次(最右边)出现位置

char *strstr( char const *s1, char const *s2 ); //查找s2第一次出现的位置
char *strtok( char *str, char const *sep ); //原理是将sep用NULL替换

char *strpbrk( char const *str, char const *group ); //查找 str 中的字符第一次在字符串中出现的位置, 返回指针
size_t strcspn( char const *str, char const *group ); //查找 str 中的字符第一次在字符串中出现的位置, 返回索引
size_t strspn( char const *str, char const *group ); //查找 str 中的字符第一次不在字符串中出现的位置, 返回索引

6. 错误信息

char *strerror( int error_number ); //

7. 字符操作

字符分类：int islower(int ch)
字符转换：int tolower( int ch )

8. 内存操作

字符串数据内部包括 0 时，用下面函数操作

void *memcpy( void *dst, void const *src, size_t length );
void *memmove( void *dst, void const *src, size_t length );
void *memcmp( void *dst, void const *src, size_t length );
void *memchr( void *dst, void const *src, size_t length );
void *memset( void *dst, void const *src, size_t length );

海涛 2010-01-05 01:32 发表评论

[POINTERS ON C] 第八章数组

海涛 — Wed, 30 Dec 2009 15:30:00 GMT

1. 一维数组

数组名的值是一个指针常量
只有当数组名在表达式中使用时,编译器才会为它产生一个指针常量

int array[9];
sizeof(array) : 数组 a 的大小9，不是指针的长度
&array : 指向数组的指针，不是某个整型数的指针
6[array] : 与array[6]相等；*(6+array)

2. 字符串复制

void
strcpy(char *buffer, char const *string)
{
while( (*buffer++ = *string++) != '\0')
;
}

3. 数组和指针

int strlen( char *string );
int strlen( char string[] );

4. 初始化

静态数组自动初始化
初始化用 {}
字符数组初始化
char message[] = { 'H', 'e', 'l', 'l', 'o', 0};
char message[] = "Hello";

5. 多维数组

下标引用只是间接访问表达式的一种伪装形式
int matrix[3][10];
int (*p)[10] = matrix;
matrix[1][5] = *( *( matrix +1 ) +5 )

matrix是一个指向数组的指针

6. 指针数组

int *api[10];
char const *keyword[] = {"do", "for", "return", NULL};
sizeof(keyword) / sizeof(keyword[0]) : 元素个数

#include <string.h>

int
lookup_keyword( char const * const desired_word, char const *keyword_table[], int const size )
{
     char const **kwp;
     for( kwp = keyword_table; kwp < keyword_table+size; kwp++)
     if(strcmp(desired_word, *kwp) == 0)
     return kwp - keyword_table;
   retrun -1;
}

改进：for( kwp = keyword_table; *kwp != NULL; kwp++)

海涛 2009-12-30 23:30 发表评论

Debian 常用命令集锦

海涛 — Wed, 23 Dec 2009 15:30:00 GMT

1. apt-get: 提供了一个用于下载和安装软件包的简易命令行界面

   apt-get install|remove
   apt-get update: 取回更新的软件包列表信息
   apt-get upgrade: 进行一次升级
   apt-get clean: 删除所有已下载的包
   apt-get autoclean: 删除老版本的已下载的包
   apt-get check: 核对以确认系统的依赖关系的完整性
   apt-get -h: 获取帮助信息

2. apt-cache:  是一个底层的工具，我们用它来操纵 APT 的二进制缓存文件，也用来在那些文件中查询相关信息

   apt-cache add 文件: 往源缓存加入一个软件包文件
   apt-cache showpkg : 显示某个软件包的全面信息
   apt-cache showsrc : 显示源文件的各项记录
   apt-cache search 表达式: 根据正则表达式搜索软件包列表
   apt-cache -h: 获取帮助信息

3. dpkg: 是一个底层的工具，像是APT，被用于从远程获取软件包以及处理复杂的软件包关系

   dpkg -i|--install : 安装deb格式软件
   dpkg -r|--remove : 删除该软件包
   dpkg -P|--purge : 完全删除该软件包
   dpkg --configure : 重新配制一个已经安装的包
   dpkg -h|--help: 获取帮助信息

海涛 2009-12-23 23:30 发表评论

[POINTERS ON C] 第七章函数

海涛 — Mon, 21 Dec 2009 15:02:00 GMT

1. 函数定义

存根 (stub) 目的
真函数 : 函数具有返回值

2. 函数声明

函数原型 : function prototype
当程序调用一个无法见到原型的函数时, 编译器便认为该函数返回一个整型

3. 函数的参数

C 函数的所有参数均以"传值调用"方式进行传递
缺省参数提升 default argument promotion : char, short > int; float > double
使用函数原型的函数不会执行缺省参数提升

4. ADT和黑盒

ADT : abstract data type

5. 递归

C 通过运行时堆栈支持递归函数的实现
尾部递归很容易改为循环形式

6. 可变参数列表

#include <stdarg.h>
va_list value;
va_start( value, input);
for( i = 0; i < input; i++ )
{
va_arg( value, int);
}
va_end( value );

注：不允许一开始就访问参数列表中间的参数，允许中途中止

海涛 2009-12-21 23:02 发表评论

[POINTERS ON C] 第六章指针

海涛 — Sat, 19 Dec 2009 15:49:00 GMT

1. 内存和指针

边界对齐：整型值存储的起始位置只能是某些特定的字节，通常是 2 的倍数
变量名字和内存位置之间的关联并不是硬件所提供的，它是由编译器实现的
硬件通过地址访问内存位置

2. 值和类型

不能简单的通过检查一个值的位来判断它的类型，而是值的使用方式

3. 指针

NULL指针

char ch = 'a';
char *cp = &ch;

*cp + 1 : b
*(cp +1) : a 的相邻内存单元的值
cp++ : a 的相邻内存单元的地址
++cp : a 的地址

*++cp : a 的相邻内存单元的值
*cp++ : a (产生cp的拷贝；cp增加；通过cp拷贝执行间接访问)

++*cp : b, ch = 'a';
(*cp)++ : a, ch = 'b';

++*++cp : a 的相邻内存单元的值+1
++*cp++ : b

实例

int
strlen( char *string )
{
    int    length = 0;
    while( *string++ != '\0' )
        length += 1;
    return length;
}

int
find_char(  char **strings, char value)
{
    char *string;
    while( ( string = *strings++ ) != NULL )
    {
        while( *string != '\0' )
        {
            if( *string++ == value )
            {
                return 1;
            }
        }
    }
    return 0;
}

海涛 2009-12-19 23:49 发表评论

[POINTERS ON C] 第五章操作符和表达式

海涛 — Fri, 18 Dec 2009 13:54:00 GMT

1. 算数操作符

加, 减, 乘, 除 : 整型值盒浮点数值
取模(%) : 整型值

2. 二进制操作符

移位操作符: <<(左移位) >>(右移位) : 整型值
位操作符: &(与) |(或) ^(异或) : 整型值

3. 赋值操作符

+= -= *= /= %=
<<= >>= &= |= ^=

4. 单目操作符

!(逻辑非) ~(位取反) -(负值) +(正值)
++ --
&(取地址) *(间接寻址)
sizeof
(cast)

5. 关系操作符

> >= < <= != ==
&& || : 短路性质

4. 条件操作符

? :

5. 左值和右值

左值：内存的一个位置
右值：一个值

海涛 2009-12-18 21:54 发表评论

[POINTERS ON C] 第四章语句

海涛 — Thu, 17 Dec 2009 13:22:00 GMT

1. 表达式语句

副作用 (side effect) 的意义

2. if 语句

C 不具备布尔变量,而是用整型来代替
else 子句从属于最靠近它的不完整的 if 语句

3. switch 语句

case 标签必须具有一个唯一的值 : 常量表达式
case 标签只是确定语句列表的进入点

下面代码 : 对字符, 单词, 行计数

switch( ch ){
case '\n':
        lines += 1;
case ' ':
case '\t':
        words += 1;
default:
        chars += 1;
}

4. goto 语句

包含 goto 标签的语句可以出现在同一个函数中的任何位置
要想立刻从深层嵌套的循环中退出只有使用 goto 语句

    while( condition1 ){
          while( condition2 ){
               while( condition3 ){
                     if( condition4 )
                            goto quit;
                }
          }
    }
quit: ;

海涛 2009-12-17 21:22 发表评论

[POINTERS ON C] 第三章数据

海涛 — Wed, 16 Dec 2009 15:42:00 GMT

1. 基本数据

char signed char unsigned char
short int unsigned short (int)
int unsigned (int)
long int unsigned long (int)
float double long double

整型字面值 0173 0x7b
字符常量 'M' '\n'
宽字节常量 L'X' L'e^'

空字符串常量 "" : 只有NULL终止符
字符串常量的直接值是一个指针 char *ptr = "Hello World!"

2. 基本声明

操作符 * : 间接访问操作，只对指针变量才是合法的

下面写法等价：

char *message;
message = "Hello World!";

char *message = "Hello World!";

隐式声明：

f( x )
{
return x + 1;
}

缺少返回类型，编译器默认返回整型
参数 x 没有类型名，同样默认为整型

typedef : 为数据类型定义新名字
#define d_ptr_to_char char * (不可取)
typedef char *d_ptr_to_char;

3. 常量

int const a;
const int a;

int const *ptr;
int * const ptr
int const * const ptr;

4. 作用域

文件作用域 : 全局变量 : static
函数作用域
代码块作用域 : 局部变量
原型作用域

5. 链接属性

external : 全局，具有 external 链接属性的实体总是具有 static 存储类型
internal : static extern
none :

6. 存储类型

auto :
static : 不能修饰函数形参，全局, 初始化为0
register :

7. static

static 用于函数定义或局部变量时，改变标识符链接属性 external 为 internal
static 用于代码块内部变量声明时，改变变量的存储类型 auto 为 static

海涛 2009-12-16 23:42 发表评论

[POINTERS ON C] 第一章快速上手

海涛 — Tue, 15 Dec 2009 14:29:00 GMT

1 空白和注释

注释不要嵌套
如果需要删除代码，最好用下面方法：

#if 0
statements
#endif

2 预处理指令 preprocessor directives

如果一些声明需要用于几个不同的源文件，可以把这些声明编写一个单独的文件

3 函数

所有传递给函数的参数都是按值传递的

gets(input) : 从标准读入一行文本，存入到给定的数组中，丢弃\n，插入\0，返回非NULL表示成功读取
puts("hello") : 把指定字符串写到标准输出，并在末尾添上\n
getchar() : 从标准读取一个字符并返回该值，无输入时返回常量EOF
putchar() : 非格式化输出
scanf("%d %c %s", &integer, &char, &string) : 格式化输入，空白符作为分隔符
printf("%d %o %x %g %c %s", input1, input2, input3, float4, char5, string6) : 格式化输出

int
read_column_number( int columns[], int max ) 未指定数组长度，数组长度为单独参数

字符只是小整数，用一个整数容纳字符不会引起任何问题

海涛 2009-12-15 22:29 发表评论

[POINTERS ON C] 第二章基本概念

海涛 — Mon, 14 Dec 2009 16:47:00 GMT

1. 环境

分为翻译环境 translation environment 和执行环境 execution environment

translation = compiler (obj) + linker (exe)

compiler = preprocessor (text operation) + parse (warning, error, obj) + optimizer (efficient)

cc main.c : 编译并链接一个源文件
cc main.c program.c : 编译并链接多个源文件
cc main.o program.c : 编译一个源文件，并把已有目标文件连接在一起

cc -c main.c : 编译源文件，并产生一个目标文件
cc -c main.c program.c : 编译多个源文件，并为每个文件产生一个目标文件
cc main.o program.o : 链接多个目标文件

execution = load (init stack var) + start (running stack) + stop (return/exit)

load : 存储在stack中尚未初始化的变量将在此时得到初始值
start : 程序使用一个running stack，存储函数的局部变量和返回地址

2. 规则

换行符可以是一串字符，但当作单个字符处理
空白字符：空格，水平制表符，垂直制表符，格式反馈符，换行符
三字母词：??(
转义序列：\? \" \' \\ \a \b \f \n \r \t \v \ddd \xddd

注释：被预处理器替换为一个空格
可以出现在任何空格可以出现的地方

规则：相邻的标记之间必须出现一至多个空白字符
y=x+1;
y = x + 1;
y = x
+
1;

大小写字母，数字，下划线组成
区分大小写
长度无限制，标准忽略掉第31个字符以后的字符
允许编译器对于表示外部名字的标识符进行限制：只识别前六位，不区分大小写

3. 程序风格

海涛 2009-12-15 00:47 发表评论