C++博客-geforceX的编程小苑-随笔分类-算法/数据结构

一个关于指针的问题

geforceX — Wed, 21 Dec 2005 02:55:00 GMT

有些东西在你没有遇到之前还真是不知道自己没有弄清楚，也许是我平时细节的地方注意少了，看来以后要多加注意了。

char *pStr;
char ch;
char str[] = "Hello";

ch = str[1];
*pStr = str[1];

printf("ch = %c\n", ch);
printf("*pStr = %c", *pStr);

此时打印ch值的时候能正确输出，但是打印pStr[0]的时候就出问题了，跟踪发现是pStr[0] = str[1];这句出现问题。

原来，char *pStr; 只定义了一个4字节的指针变量，而这个变量里面的内容是将要指向一个char类型变量的，但是此时pStr只是个“野指针”，并没有指向一个char类型的内存单元，所以，当用*pStr来访问这个元素时，系统根本不知道该访问何处的空间，因此，在使用pStr前，必须让它指向一个具体的空间。

由上面可以将相关语句改为

char *pStr;
char ch;
char str[] = "Hello";

pStr = &ch; //pStr指向ch、获得初始化
pStr = &str[1]; //pStr指向str[1]地址、获得初始化
ch = str[1];
*pStr = str[1];

printf("ch = %c\n", ch);
printf("*pStr = %c", *pStr);

也就是说，要先给指针一个地址值初始化它，然后才能用*访问它指向的内容。

◎另外，在子函数中使用malloc()/new()分配的内存空间不会因子函数的返回而消失，函数只会清理调子函数里定义的变量的空间，如：

char* func()
{
  char *p;
  p = (char *)malloc(sizeof(char));

  return p;
}  //返回后，p所在空间被释放，但是p所指空间还存在

所以，可以用p1=func();来获得在func()中分配的空间。

此中方法可以用来解决“指针的指针”使用不方便的问题。步骤分2步：1、把传入的指针的指针参数去掉；2、把函数的返回值赋给要改变的对象的指针：

void GetMemory2(char **p, int num)
{
  *p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
  char *str = NULL;
  GetMemory2(&str, 100);   // 注意参数是 &str，而不是str
  strcpy(str, "hello");
  cout<< str << endl;
  free(str);
}

//////下面是用传递动态内存的方法实现
char *GetMemory3(int num)
{
  char *p = (char *)malloc(sizeof(char) * num);
  return p;
}
void Test3(void)
{
  char *str = NULL;
  str = GetMemory3(100);
  strcpy(str, "hello");
  cout<< str << endl;
  free(str);
}

因为此时用malloc/new分配的内存空间是堆里面的，函数返回时不会回收；而如果在子函数中用char p[]="asdfgewq";则p是在栈中定义的（先分配p的空间，然后讲字符串拷贝进去，跟char *p="asdfasdf"分配在全局静态内存中不一样），所以会被系统收回。

geforceX 2005-12-21 10:55 发表评论

数组和指针的比较

geforceX — Sun, 18 Dec 2005 13:40:00 GMT

1。定义数组变量时必须指定数组元素个数，因为系统会根据元素个数在编译时一次性分配这么多内存；
而指针变量只需要指定类型，系统只为该指针变量分配4字节（32位机）内存，而不会为该变量所指内容分配内存。

2。指针变量是有存储空间的；而数组名仅仅是一个标号，没有实际存储空间，单单一个数组名就只能表示该数组的第1个元素的地址。int a[10]; 规定&a就等于&a[0]或者a .

3。例如 char str[]= "hello world"和char *p = "hello world"中，数组str是先分配给他元素个数个内存，然后将后面的字符串复制给这个空间（注意，此时应该考虑\0字符）；而p的建立过程是先在静态存储区建立常字符串"hello world\0"，然后将p指向这个常字符串。所以数组str中元素的内容可以通过重新赋值改变，而p指向的内容不能改变。

geforceX 2005-12-18 21:40 发表评论

C++里"const"关键字相关问题

geforceX — Sat, 10 Dec 2005 12:08:00 GMT

转载的一篇文章：

本篇主要写给对const语法理解存在误区的c++学习者，希望所有对这方面比较模糊的朋友可以阅读并从中找到一些答案。
。
2004-11-19 21:00
Const 最早想法是用于取代预处理器#define 这个宏，从而形成常量的概念。针对常量const对象，const指针及指向const的指针，函数const类型参数，const 函数返回类型， const类成员，及const成员函数，及对const最后理解的一些总结来描述 const。
① const对象和const类型的对象
对于这两个概念的描述如下
1. int const Object; //Object是一个const量是不可以被修改 Object = 2;Error
2. const int Object; //Object是 const int型他所存放的内容不可以被修改
对于1，2这两种const用于对象，表述虽然不同但是效果是一样的。因为对象本身存放着内容对对象的改变就是对于对象内容的改变，同样改变后者也是在改变前者。所以语义上一样的。
② const指针和指向const的指针及两者结合
对于三个概念描述如下
1. int* const p; //指针p是const不能被修改例如p++; //修改p本身会Error
//修改p指向内容 *p = 2; //OK
2. const int* p; //p是指向一个整形常量的指针指向的内容不可以改变 p++;//OK
// *p = 2; //Error
3. const int* const p; //指针p本身是不能被修改并且p所有有效的内容也不能被
//修改 *p = 2; Error 和 p++; Error
③ const 参数修饰和参数返回类型的const修饰
1.const 参数修饰
此时函数参数修饰 const的具体用法 ① ②中用法是一样的
例如 void Fun( const int I ) { I++;} //Error不能修改常量I
2.const修饰函数返回类型用法也是类似于 ①②中,仅仅修饰的对象变化变成一个返回对象
例如：const int Fun() { static int I; return I;}
int Res = (Fun())++ //Error不能修改常量返回对象
④ const类成员和 const 成员函数
1. const成员
类const成员在构造期间会允许被初始化并且在以后不能被改变。我们就可以知道类const成员和一般const 变量是有所不同的，类const成员是对应于每个对象而言才有意义。因为他在构造期被初始化，只有当类实例化后才会进行构造。所以类const成员可以这样描述: 在类的每一次实例化时被初始化，在这个对象的生存周期中不可改变。
2. const 成员函数
描述: void Class::MemberFun() const {}; //此时这个const修饰的this所有类成员变量都不允许在这个函数体作用后被修改。这在设计上会带来一些好处，能防止你意外的处理带来的问题。
总结:
<1> const 常量一般编译器不会分配空间只是维护一张表。而当extern 外部引用这个常量或者“&”对这个常量取地址时，编译器才会为其分配地址。Const本身的机制比较复杂。
<2> const 记忆法则 const修饰后面一个最近的名称。我曾初学的时候被const 修饰搞的糊里糊涂，后来慢慢的总结我觉得这样理解最容易的。
例子: const int I; 此时const仅仅修饰int 表明 I不是一个常量但是I的内容是常量。因为c/c++表达对I的改变就是对I内容的改变所以 I也类似一个const。大家不妨可以用指针const修饰试试理解会有帮助的我想。
<3> 对于所有非const 类型可以无条件转化为 const类型，但是后者不能自动转化为前者除非显式的强制转化去掉const性。这样做是有意义的，因为const类型是非const的一个子集是一种特殊，由普遍转化为特殊是合理的，就象模板特化，继承的向上映射都是有意义的。
<4> 记住所有const修饰的内容并不是永远不可改变，如果人为的强制转化编译器是不会提醒的。因为它没有义务这么做，所以我们对其转化时要小心。
<5> 在const类成员函数处理时，我们引入了mutable修饰类成员变量，经过其修饰的成员变量可以在const类成员函数中被修改，编译器是允许的。而其他未被mutable修饰的成员还是按照const规则不能在const成员函数中被改变。

函数后面加“const”与不加是两个不同函数，如：

#include

using namespace std;

class A
{
public:
A(int i, int j){a = i; b = j;}
void print();
void print() const;
private:
int a, b;
};

void A::print()
{
cout << "hello!" << a << b << endl;
}
void A::print() const
{
cout << "hello const!" << a << b << endl;
}

int main()
{
A ss(3,6); // 定义A的对象时，没有用“const”
ss.print();
A const dd(20,2); // 定义A的对象时，用了“const”
dd.print();
}

geforceX 2005-12-10 20:08 发表评论

原码、反码、补码

geforceX — Fri, 09 Dec 2005 11:32:00 GMT

昨天去参加笔试，遇到了一题考计算机里存放的数据都是以原码、反码、还是补码的形式存放的。我还真的很久没有考虑过原码补码的问题了，不过凭他考这个问题，我可以猜出答案一定是补码了。虽然答案知道了，但是还真不知道还有这么一说，所以回来在网上搜了一篇这样的文章，才算是弄清楚是怎么一回事了：

数值有正负之分,计算机就用一个数的最高位存放符号(0为正,1为负).这就是机器数的原码了.假设机器能处理的位数为8.即字长为1byte,原码能表示数值的范围为

(-127~-0 +0~127)共256个.

有了数值的表示方法就可以对数进行算术运算.但是很快就发现用带符号位的原码进行乘除运算时结果正确,而在加减运算的时候就出现了问题,如下: 假设字长为8bits

( 1 ) ₁₀- ( 1 )₁₀ = ( 1 )₁₀ + ( -1 )₁₀ = ( 0 )₁₀

(00000001)_原 + (10000001)_原 = (10000010)_原 = ( -2 ) 显然不正确.

因为在两个整数的加法运算中是没有问题的,于是就发现问题出现在带符号位的负数身上,对除符号位外的其余各位逐位取反就产生了反码.反码的取值空间和原码相同且一一对应. 下面是反码的减法运算:

( 1 )₁₀ - ( 1 ) ₁₀= ( 1 ) ₁₀+ ( -1 ) ₁₀= ( 0 )₁₀

(00000001) _反+ (11111110)_反 = (11111111)_反 = ( -0 ) 有问题.

( 1 )₁₀ - ( 2)₁₀ = ( 1 )₁₀ + ( -2 )₁₀ = ( -1 )₁₀

(00000001) _反+ (11111101)_反 = (11111110)_反 = ( -1 ) 正确

问题出现在(+0)和(-0)上,在人们的计算概念中零是没有正负之分的.(印度人首先将零作为标记并放入运算之中,包含有零号的印度数学和十进制计数对人类文明的贡献极大).

于是就引入了补码概念. 负数的补码就是对反码加一,而正数不变,正数的原码反码补码是一样的.在补码中用(-128)代替了(-0),所以补码的表示范围为:

(-128~0~127)共256个.

注意:(-128)没有相对应的原码和反码, (-128) = (10000000) 补码的加减运算如下:

( 1 ) ₁₀- ( 1 ) ₁₀= ( 1 )₁₀ + ( -1 )₁₀ = ( 0 )₁₀

(00000001)_补 + (11111111)_补 = (00000000)_补 = ( 0 ) 正确

( 1 ) ₁₀- ( 2) ₁₀= ( 1 )₁₀ + ( -2 )₁₀ = ( -1 )₁₀

(00000001) _补+ (11111110) _补= (11111111)_补 = ( -1 ) 正确

所以补码的设计目的是:

⑴使符号位能与有效值部分一起参加运算,从而简化运算规则.

⑵使减法运算转换为加法运算,进一步简化计算机中运算器的线路设计

所有这些转换都是在计算机的最底层进行的，而在我们使用的汇编、C等其他高级语言中使用的都是原码。看了上面这些大家应该对原码、反码、补码有了新的认识了吧！

下面总结一下：
1。正数的原码反码补码都相同，负数的反码是除符号位为1外，其他位全取反；补码就是反码+1
2。(10000000)_补规定为-128
3。计算机中的数据是以补码形式存储的

geforceX 2005-12-09 19:32 发表评论

终于弄清了几个长期模模糊糊的问题

geforceX — Sat, 26 Nov 2005 02:33:00 GMT

int型在16位、8位机上默认的是short int型，占2个字节，所以51单片机开发上的int类型都是2字节
在32位机上默认的是long int型，占4个字节，所以一般PC上int类型都是4字节

指针类型所占空间不会因为所指变量类型的不同而不同，在16位8位机上都是2字节；在32位机上都是4字节，如char *a、int *b， sizeof(a)、sizeof(b)全部都等于4

signed char 类型的取值范围是 -128~127

geforceX 2005-11-26 10:33 发表评论