久久九九精品99国产精品,九九99精品久久久久久,国产精品乱码久久久久久软件

内存��理

Sat, 05 Jun 2010 01:34:00 GMT

扩展阅读

内存的三�U�分配方式：

1�Q?nbsp;从静态存储区分配�Q�此时的内存在程序编译的时候已�l�分配好�Q��ƈ且在�E�序的整个运行期间都存在。全局变量�Q�static变量�{�在此存储�?/p>

2�Q?nbsp;在栈区分配：相关代码执行时创建，执行�l�束时被自动释放。局部变量在此存储。栈内存分配�q�算内置于处理器的指令集中，效率高，但容量有限�?/p>

3�Q?nbsp;在堆区分配：动态分配内存。用new/malloc时开辟，delete/free旉��放。生存期��q��h��定，灉|��。但有内存泄露等问题�?/p>

常见内存错误及对�{?/p>

1�Q?nbsp;内存分配未成功，却被使用�?/p>

对策�Q��用内存之前检查是否分配成功。用p!=NULL判断�?/p>

2�Q?nbsp;内存分配成功�Q�未初始化就被��用�?/p>

内存的缺省值没有统一的标准。大部分�~�译器以0作�ؓ初始��|��但不完全是�?/p>

对策�Q�内存初始化时赋初倹{�?/p>

3�Q?nbsp;内存操作��界�?/p>

对策�Q�只能是��心了�?/p>

4�Q?nbsp;释放了内存，仍然使用�?/p>

�Q?�Q?nbsp; 使用昄��delete和free的野指针�?/p>

对策�Q�释攑֮�内存�Q�将指针�|��ؓNULL�?/p>

�Q?�Q?nbsp; 使用隐式delete和free的野指针。主要是指函数返回指向栈内存的指针或引用�?/p>

对策�Q�当然是不要�q�回��可以了�?/p>

5�Q?nbsp;未释攑ֆ�存，��D��内存泄露�?/p>

用new/malloc开辟了内存�Q�没用delete/free释放.

对策�Q�new和delete的个��C��定相同；malloc和free的个��C��定相同；new[]和[]delete一定对应�?br>

�C�Z��1�Q�返回指向栈�I�间的指�?br>

1char* test1()
2{
3    char str[] = "Hello World!";
4    return str;
5}
6
7char* test2()
8{
9    char *str = "Hello World!";
10    return str;
11}
12
13char* test3()
14{
15    static char str[] = "Hello World!";
16    return str;
17}
18
19void main()
20{
21    char *str = NULL;
22
23        str = test1();
24    cout << str << endl; //垃圾信息
25
26    str = test2();
27    cout << str << endl; //ok
28    //str[1] = 'A' ; //error.试图修改常字�W�串
29         //str = NULL; //error.试图修改常字�W�串
30
31    str = test3();
32    cout << str << endl;
33}
34

输出�l�果�Q?br>��q��

Hello World!

Hello World!

�C�Z��2�Q?/span>new�?/span>delete虽然对应�Q�但delete释放不成�?/span>

void main()
{
    char* p = new char[4];

    p = "ppp";

    delete []p;
}

�q�行旉��误�?/span>P虽然是动态开辟的内存�Q�但在第二条语句�?/span>p已经指向了静态存储区上的地址�Q�而对指向静态存储区的指针是不能�?/span>delete释放的。此时不仅运行时错误�Q�还有内存泄霌Ӏ?/span>

�q�运�?/a> 2010-06-05 09:34 发表评论

sscanf

Sun, 25 Apr 2010 12:13:00 GMT

int sscanf(const char* str, const char* format, ...)
functions: Reads data from str and stores them according to the parameter format into the locations given by the additional arguments. Locations pointed by each additional argument are filled with their corresponding type of value specified in the format string.

In the format:
Whitespace character: the function will read and ignore any whitespace characters which are encounterd before the next non-whitespace character.
Non-whitespace character: except percentage signs(%): any character that is not either a whitespace character or part of a format specifier causes the function to read the next character from str, compare it to this non-whitespace character and if it matches, it is discarded and the function continues with the next character of format and str. If the character does not match, the function fails and returns.
Return Value:
On success. the function returns the number of items successfully read.
On failure: In the case of an input failure before any data could be successfully read, EOF is returnded.

   //默认以空格分隔str��Z��同字�W�串,�q�回正确输入的变量个�?nbsp;
   char buf1[512] = {0};
   cout  << sscanf("abc def gh","%s",buf1) <<endl;   //1
   cout << buf1 << endl; //abc

   //可以使多个一起存�?nbsp;
   char buf2[512] = {0};
   char buf3[512] = {0};
   cout << sscanf("abc 2def gh","%s%s",buf2,buf3) <<endl;  //2
   cout << buf2 << endl; //abc
   cout << buf3 << endl;//2def

   //�I�格或format格式以外的字�W�如果匹配则与前一个字�W�串一赯��入，否则停止�Q�退�?nbsp;
   char buf4[512] = {0};
   char buf5[512] = {0};
   cout << sscanf("abc 2def gh","%s,%s",buf4,buf5) <<endl; //1
   cout << buf4 << endl; //abc
   cout << buf5 << endl; //nothing

   char buf6[512] = {0};
   char buf7[512] = {0};
   //注意两个%s之间的空��g��可少
   sscanf("abc 2def gh","%s 2%s",buf6,buf7);
   cout << buf6 << endl; //abc
   cout << buf7 << endl; //def

   //当然不只是字�W�串形式的，其他也都可以
   char buf8[512] = {0};
   int a;
   cout << sscanf("abc 2def gh","%*s %d",&a) <<endl;//1
   cout << a << endl;//2

   //Failure
   int b;
   cout << sscanf("abc","%d",&b) <<endl; //0

�q�运�?/a> 2010-04-25 20:13 发表评论

sprintf

Sun, 25 Apr 2010 11:23:00 GMT

sprintf: http://www.cplusplus.com/reference/clibrary/cstdio/sprintf/

Portotype: int printf(char* str, const char* format, parameters);

Writes into the array pointed by str a C string consisting on a sequence of data formatted as the format argument specifies. After the format parameter, the function expects at least as many additional arguments as specified in format.

This function behaves exactly as printf does, but writing its result to a string instead of stdout. The size of the array passed as str should be enough to contain the entire formatted string .

Return value:

On success, the total number of characters written is returned. This count does not include the additional null-character automatically appended at the end of the string.

//Success
//The size of str is long enough
//the number of additional number match with the format
const int size = 25;
char *str = new char[size];

//same as int flag1 = sprintf(str,"%s is written to str.","Test","tEST");
int flag1 = sprintf(str,"%s is written to str.","Test");
//Console: 23-Test is written to str
cout << flag1 << "-" << str << endl;

On failure, a negative number is returned.

//Failure1
//additional arguments numbers is less than specified is format
//the second %s transmited as unrecognizable words
const int size = 25;
char *str = new char[size];
int flag2 = sprintf(str,"%s %s tttttttttttt","Test");
//Console: 19--Test @ tttttttttttt
cout << flag2 << "--" << str << endl;

//Failure2:the size of str is not long enough
// 在dev c++不能�q�行�Q�vc6.0沒有问题
const int size = 25;
char *str = new char[size];
int flag3 = sprintf(str,"%s jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj","Test");
//VC6.0 Console: Test jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj
//Dev c++: Console: the same as vc6.0 but throws an cannot read memory exception
cout << flag3 << "--" << str << endl;

没有��试��Z��么时候出错返回负值呢�Q�！谁给我一个例子？

�q�运�?/a> 2010-04-25 19:23 发表评论

Mon, 19 Apr 2010 00:49:00 GMT

与复制构造函数和复制操作�W�不同，�~�译器��L��提供合成析构函数�?br>
合成析构函数做什么？
按对象创建时的逆序撤销每个非static成员�Q�包括指针成员�?br>只不�q�不删除指针成员所指向的对象�?/span>

�q�运�?/a> 2010-04-19 08:49 发表评论

Sun, 18 Apr 2010 11:59:00 GMT

当在�cȝ��构造函��C��中申请了资源(如内存空�?�Q�需要在对象被销毁时�q�行释放时�?

class Test
{
public:
    Test(const char* ptr)
    {
        if(ptr)
        {
            p = new char[strlen(ptr)];
        }
    }
    ~Test()
    {
        delete[] p;
    }
private:
    char* p;

};

�q�运�?/a> 2010-04-18 19:59 发表评论

指针学习2--内存泄露

Sun, 18 Apr 2010 04:06:00 GMT

内存泄露的情�?br>�Q?

1#include <iostream>
2using namespace std;
3
4class Stu
5{
6   public:
7         Stu(int m):var(m)
8         {
9                  cout << var <<" constructor called." << endl;
10         }
11          ~Stu() { cout << var << " destructor called." << endl;}
12   private:
13          int var;
14};
15
16
17int main()
18{
19    Stu *a = new Stu(20);
20    Stu *b = new Stu(30);
21    delete b;
22    return 0;
23    //or 其他隐藏异常
24
25    //��D��内存泄露
26    delete a;
27
28    return 0;
29}

�q�运�?/a> 2010-04-18 12:06 发表评论

指针学习1--new &delete & destructor

Sun, 18 Apr 2010 02:58:00 GMT

1. 一般指针的new&delete

对于指针a,delete a之后�Q�指�?/span>a 的地址仍然是原来的地址(�q�不是NULL)�Q�只不过所指向的对象被释放了，此时指针存放的��gؓ随机的，��q��译器��定�?br>

1     int *a = new int(2);
2     cout << "after new :" << endl;
3     cout << "a = " << a << "," << "*a = " << *a << endl;
4
5     delete a;
6     cout << "after delete: " << endl;
7     if(a == NULL)
8     {
9         cout << "a is null after delete" << endl;
10     }
11     else
12     {
13         cout << " a is not null after delete" << endl;
14     }
15     cout << "a = " << a << "," << "*a = " << *a << endl;

//好的�~�程习惯
delete a;
a = NULL;

常规�Ҏ(gu��)��创徏的对象，当实际对象（而不是对象的引用�Q�超��Z��用域�Ӟ��才会�q�行析构函数
动态方法创建的对象�Q�当删除指向动态分配对象的指针�Ӟ��才会�q�行析构函数�?nbsp;

2. 一般类对象的声明与初始化：不用new也可以定义类对象�Q�区别于java�Q�，默认调析构函�?br>注：为方便简单演�C�，�q�没有遵循三法则

1class Stu
2{
3   public:
4         Stu(int m):var(m)
5          {
6                  var = m;
7                  cout << "constructor called." << endl;
8          }
9          ~Stu() { cout << var << " destructor called." << endl;}
10   private:
11          int var;
12};
13
14void func()
15{
16       //调用构造函�?/span>
17       Stu a(20);
18       //调用默认复制构造函�?/span>
19       Stu b(a);
20       //�{��h(hu��n)于Stu temp(b); Stu b(temp);
21       //所以有调用构造函数的�q�程
22       Stu c = 30;
23       //都是用隐式方式定义的�Q�所以不用delete,自动调用析构函数
24 |        //注意析构的顺�?nbsp;
25}
26
27int main()
28{
29   func();
30   return 0;
31}

�q�里有一个需要注意的地方�Q�就是如果func里面的代码是直接写在main里的则不一定调用析构函�?nbsp;�Q�由�~�译器决定�?br>上面是dev c++, 下面是vc6.0的运行结�?br>

1
2int main()
3{
4
5    //{
6       //调用构造函�?/span>
7       Stu a(20);
8       //调用默认复制构造函�?/span>
9       Stu b(a);
10       //�{��h(hu��n)于Stu temp(b); Stu b(temp);
11       //所以有调用构造函数的�q�程
12       Stu c = 30;
13       //new出来的指针对象，必须昄��delete,如a,b
14       //�c�d��象结束局部范围后会自动调用析构函�?nbsp;如c
15    //}
16    return 0;
17}

3. 用new定义�c�d��?必须delete
动态分配的对象只有在指向该对象的指针被删除时才撤销。如果没有删除指向动态对象的指针�Q�则不会�q�行该对象的析构函数�Q�对象则一直存在，从而导致内存泄霌Ӏ?br>常规�Ҏ(gu��)��创徏的对象，当实际对象（而不是对象的引用�Q�超��Z��用域�Ӟ��才会�q�行析构函数
动态方法创建的对象�Q�当删除指向动态分配对象的指针�Ӟ��才会�q�行析构函数�?br>

1class Stu
2{
3   public:
4         Stu(int m):var(m)
5          {
6                  var = m;
7                  cout << "constructor called." << endl;
8          }
9          ~Stu() { cout << var << " destructor called." << endl;}
10   private:
11          int var;
12};
13
14void func()
15{
16       //调用构造函�?/span>
17       Stu* a = new Stu(20);
18       //调用默认复制构造函�?/span>
19       Stu* b= new Stu(*a);
20       //�{��h(hu��n)于Stu temp = new Stu(30); Stu b(temp);
21       //所以有调用构造函数的�q�程
22       Stu c = 30;
23       //new出来的指针对象，必须昄��delete,如a,b
24       //�c�d��象结束局部范围后会自动调用析构函�?nbsp;如c
25       delete a;
26       delete b;
27}
28
29int main()
30{
31   func();
32   return 0;
33}

�q�运�?/a> 2010-04-18 10:58 发表评论

宏与内联(inline)的区�?转蝲)

Thu, 04 Mar 2010 12:22:00 GMT

先�{载下人家�ȝ��的宏和普通函数调用的区别�Q?br>(1)、宏只做��单的字符串替换，函数是参��C��递，所以必然有参数�c�d��?支持各种�c�d��Q�而不是只有字�W�串)�?br>(2)、宏不经计算而直接替换参敎ͼ�函数调用则是��参数表辑ּ�求值再传递给形参�?br>(3)、宏在编译前�q�行�Q�即先替换再�~�译。而函数是�~�译后，在执行时才调用的。宏占编译时��_��而函数占执行旉��?br>(4)、宏参数不占�I�间�Q�因为只做字�W�串替换�Q�而函数调用时参数传递是变量之间的传递，形参作�ؓ局部变量占内存�I�间�?br>(5)、函数调用需要保留现场，然后转入调用函数执行�Q�执行完毕再�q�回主调函数�Q�这些耗费在宏中是没有的�?/p>

使用宏和内联函数都可以节省在函数调用斚w��的时间和�I�间开销。二者都是�ؓ了提高效率，但是却有着显著的区别：
(1)、在使用�Ӟ��宏只做简单的预处理器�W�号�?字符�?中的��单替换。而内联函数可以进行参数类型检查，且具有返回�?也能被强制�{换�ؓ可�{换的合适类�?�?br>(2)、内联函数首先是函数�Q�函数的许多性质都适用于内联函�?如内联函数可以重�?�?br>(3)、内联函数可以作为某个类的成员函敎ͼ��q�样可以使用�cȝ��保护成员和私有成员。而当一个表辑ּ�涉及到类保护成员或私有成员时�Q�宏��׃��能实��C��(无法��this指针攑֜�合适位�|?�?/p>

可以用内联函数完全替代宏�?br>但是在��用内联函数时也要注意�Q�作为内联函敎ͼ�函数体必��d��分简单，不能包含循环�Q�条�Ӟ��选择�{�复杂结构，否则不能作�ؓ内联函数�?br>实际上，�~�译器的优化�pȝ��会自动将一些简单函数变成内联函数。而一些复杂的函数�Q�即使指定�ؓ内联�Q�编译器也会自动当作普通函数�?/p>

文章出处�Q�DIY部落(http://www.diybl.com/course/3_program/c++/cppxl/20081216/154041.html)

�q�运�?/a> 2010-03-04 20:22 发表评论

Sun, 24 Jan 2010 06:36:00 GMT

摘要: Quicksort是一个很好的比较排序��法�Q�但是其最坏情况运行时间是O(n^2), �q�不如Mergesort的O(nlgn),
如何改进Quicksort? �{�案是：引进随机化思想�?
一�U�方法：对给定的待排序序列，随机地重排列
另一�U�方法：随机选取pivot

�l�出�W�二�U�方法的代码阅读全文

�q�运�?/a> 2010-01-24 14:36 发表评论

Order Statistics ��序�l�计�Q�找出第i��元素）

Thu, 21 Jan 2010 08:29:00 GMT

摘要:
Order Statistics ��序�l�计
Select(int* a, int n, int ith): 从给定的n个元素中扑և��W�i个小的元�?
思想�Q�QuickSort的Partition�Ҏ(gu��)��q�行分割
如果 i = rank(pivot), 则返回a[k]
如果 i < rank(pivot), 则从前半部分中找�W�i个小的元�?
如果 i > rank(pivot), 则从后半部分中找�W�i-rank(pivot)个小的元�?
最坏运行时间O(n^2)
�q�_��q�行旉��O(nlgn) 阅读全文

�q�运�?/a> 2010-01-21 16:29 发表评论