C++博客-God bless XLYZ!!!-随笔分类-C++ Zealot!

const 的用法以及误区

xlyz.os — Sun, 06 Jun 2010 02:00:00 GMT

const 常见用法

const是C++语言的一种关键字，起受保护，防止以外的变动的作用！可以修饰变量，参数，返回值,甚至函数体。const可以提高程序的健壮性，你只管用到你想用的任何地方。
1. const修饰参数。const只能修饰输入参数。
   1）如果输入参数是指针型的，用const修饰可以防止指针所指向的内容被意外修改。
   2）如果参数采用值传递的方式，无需const，因为函数自动产生临时变量复制该参数。
   3）非内部数据类型的参数，需要临时对象复制参数，而临时对象的构造，析构，复制较为费时，因此建议采用前加const的引用方式传递非内部数据类型。而内部数据类型无需引用传递。

2.   const修饰函数返回值。
   1）函数返回const指针，表示该指针不能被改动，只能把该指针赋给const修饰的同类型指针变量。
   2）函数返回值为值传递，函数会把返回值赋给外部临时变量，用const无意义！不管是内部还是非内部数据类型。
   3）函数采用引用方式返回的场合不多，只出现在类的赋值函数中，目的是为了实现链式表达。

3.   const+成员函数。任何不修改数据成员的函数都应该声明为const类型，如果const成员函数修改了数据成员或者调用了其他函数修改数据成员，编译器都将报错！

【误区1】

const int* a = &b;                 /* [1]*/
int const *a = &b;                 /* [2]*/
int* const a = &b;                 /* [3]*/
const int* const a = &b;           /* [4]*/

看看上面的4行代码，或许可以这么理解：

如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。

但是我想上面的解释不一定正确. 关于const int* a = &b, 并不是说a所指向的是常量，而应该理解成: a所指向的内容不能通过*a来改变，对于a所指向的内容是不是常量并没有限制。如下面的代码，是可以通过编译的。

    const int *p = &b;

    int *q = &b;

    *q++;

【误区2】C++中的const 是具有内部链接的（不同于C）

下面是摘自C++中关于链接的一段话:

— When a name has external linkage, the entity it denotes can be referred to by names from scopes

other translation units or from other scopes of the same translation unit.

— When a name has internal linkage, the entity it denotes can be referred to by names from other scope

the same translation unit.

— When a name has no linkage, the entity it denotes cannot be referred to by names from other scopes.

A name having namespace scope (3.3.5) has internal linkage if it is the name of

— an object, reference, function or function template that is explicitly declared static or,

— an object or reference that is explicitly declared const and neither explicitly declared extern nor

previously declared to have external linkage; or

— a data member of an anonymous union.

从上面可以看出const对象是具有内部链接的。

内部链接的意思就是:

/*----A.h------*/

int a;

const int b;

/*----test1.cc-------*/

#include “A.h”

/*----test2.cc-------*/

#include “A.h”

当test1.cc 和test2.cc 链接的时候，a会出现变量重定义的错误，而b是不会的。因为b是具有内部链接的变量，相当于在test1.cc和test2.cc中各有一份b的符号。

const变量放在头文件中是不会引起链接时候的重复定义的，但是也不推荐将const变量放在头文件中。

const变量不是在编译的时候进行常量折叠，相当于宏的替换，const变量是不占内存的。

但是在某一些情况下,编译器会为const分配内存,比如:

const int a = 10;

const int *p = &a;

当你想获取const变量的地址时（当然你也可以将a的地址打印出来看看），编译器就会强制为const变量分配内存了。所以当你在含有const变量的头文件被多个编译单元包含时，const变量也有可能在编译单元中占据内存。所以一般是不推荐将const 或者static变量放在头文件中。当然这样做也无可厚非。

下面这种情况const也是会分配内存的:

const int a[5] = {1, 2, 3, 4, 5};

所以下面的语句也就自然而然是不能通过编译的了:

int arr[a[2]];

虽然a[2]的类型也是const int,但是它与下面的这种情况是有区别的:

const int k = 3;

int arr[k];

因为k是const 类型，在编译的时候进行了常量折叠。而上面的a[2]虽然也是const int型，但是它存在于内存中。数组声明时数组的维数是不允许用内存中的数据来定义的。所以编译器会在此报出illegal的错误。

当然可能不同的编译器会有不同的编译结果。比如在gcc下你编译上述的代码会诡异的通过，但是这是不符合C++标准的。当然如果你加上参数-pedantic的话，你就会发现编译器乖乖的听你的话了。

const变量在大部分情况下是编译时的常量，如果需要运行时的常量，应该怎么做呢？像下面的代码这样:

const int const_runtime = get_v() // get_v在其他地方定义

又或者对运行时的变量加锁，让其变为只读的？不管怎样，要想获得运行时的常量，方法还是很多的。欢迎交流。

上述只是个人理解，如有错误的地方，还望指教.

xlyz.os 2010-06-06 10:00 发表评论

一个小程序。打发时间...

xlyz.os — Tue, 27 Oct 2009 15:15:00 GMT

/*
* =====================================================================================
*
*       Filename:  distribute.cc
*
*    Description:  7 = 1+6
*                         7 = 2+5
*                         7 = 3+4
*                         7 = 1+1+5
*                         7 = 1+2+4
*                         7 = 1+3+3
*                         7 = 2+2+3
*                         7 = 1+1+1+4
*                         7 = 1+1+2+3
*                         7 = 1+2+2+2
*                         7 = 1+1+1+1+3
*                         7 = 1+1+1+2+2
*                         7 = 1+1+1+1+1+2
*                         7 = 1+1+1+1+1+1+1
*
*        Version:  1.0
*        Created:  08/31/09 13:50:08
*       Revision:  none
*       Compiler:  gcc
*
*         Author:  Xlyzalleyoop (WL), xlyz.os@gmail.com
*        Company:  XLYZ
*
* =====================================================================================
*/
#include <iostream>
using namespace std;

typedef unsigned int u32;
const u32 MAX_RES = 1024;
int main(int argc, char* argv[])
{
    cout << "input the data you wanna distribute:";
    u32 n = 0;
    cin >> n;
    if (n/2 <= 0)
        return 0;
    u32** res = new u32*[MAX_RES];
    for (u32 i=0; i<MAX_RES; i++)
        res[i] = new u32[n];

    u32 current_row=0;
    for (u32 i=1; i <= n/2; i++)
    {
        u32 current_col=0;
        while (res[current_row][current_col])
            current_col++;
        res[current_row][current_col] = i;
        res[current_row++][++current_col] = n-i;
    }

    u32 start_row = 0;
    u32 end_row = current_row;

    u32 counter=2;
    while (counter++ < n)
    {
        for (u32 i=start_row; i<end_row; i++)
        {
            u32 j=0;
            while (res[i][j])
                j++;
            if (j<1)
            {
                cout << "ERROR" << endl;
                return 0;
            }
            u32 split_val = res[i][--j];
            u32 comp_val = res[i][--j];

            for (u32 k=1; k<=split_val/2;k++)
                if (k>=comp_val && (split_val-k)>=comp_val)
                {
                    u32 m=0;
                    while (res[i][m])
                        res[current_row][m] = res[i][m++];
                    res[current_row][m--] = split_val - k;
                    res[current_row][m] = k;
                    ++current_row;
                    if (MAX_RES == current_row)
                    {
                        cout << "the array is not enough\n";
                        return 0;
                    }
                }
        }
        start_row = end_row;
        end_row = current_row;
    }

    u32 row=0;
    u32 col=0;
    u32 non_zero_col=0;
    while(res[row][col])
    {
        cout << n << " = ";
        while (non_zero_col < n && res[row][non_zero_col])
            ++non_zero_col;
        for (; col<non_zero_col-1; ++col)
            cout << res[row][col] << " + ";
        cout << res[row][col] << '\n';
        ++row;
        col=0;
        non_zero_col=0;
    }
    for (u32 m=0; m <MAX_RES; m++)
        delete []res[m];
    delete []res;
    return 0;
}

xlyz.os 2009-10-27 23:15 发表评论

Coding Finished

xlyz.os — Wed, 18 Feb 2009 15:53:00 GMT

花了2个多小时终于完成了。
Note（int to string）：e.g:

  ostringstream ss;
  ss << mappedCounterArray[i];
  string str = ss.str();

#include <iostream>
#include <string>
#include <fstream>
#include   <sstream>
using namespace std;

typedef bool BOOL;
const int MAX_OF_LINE = 100;
const int mappedCounterArray[]=
{
    2605, 2606, 2618, 2619,
    2609, 2610, 2622, 2623,
    2612, 2624, 2651, 2663,
    2613, 2625, 2652, 2664,
    1627, 1628,
    1623, 1624, 1625, 1626,
    48, 49, 50, 51, 52, 54, 55, 56, 1326, 1327, 1328, 1329,
    53,
    564, 565,
    588, 589,
    592, 593, 594, 595,
    596, 597,
    1616, 1617, 1618, 1619, 1621, 1659, 1660,
    1620, 1657, 1662, 1663, 1664, 1665,
    1630, 1631, 1635, 1649, 1650, 1651, 1652,
    1634, 1653, 1654, 1655,
    1647, 1648,
    1666,
    1667,
    1668, 1669, 1672, 1673, 1674, 1675,
    1670, 1671, 1676, 1677, 1678, 1679,
    1163, 1164,
    1711, 1712, 1713, 1714,
    1715, 1716, 1717, 1718, 1743, 1744, 1745, 1746,
    1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727,
    1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742,
    590, 591,
    2728
};

BOOL isMappedCounter(const string& counterIDStr)
{
    int size = sizeof(mappedCounterArray)/sizeof(int);
    int i=0;
    while (i<size)
    {
        ostringstream ss;
        ss << mappedCounterArray[i];
        string str = ss.str();
        str += " ";
        str = " " + str;

        if (counterIDStr.find(str)<counterIDStr.length())
            return true;
        i++;
    }
    return false;
}

void setFile(void)
{
    ifstream in_file;
    in_file.open("./abc.txt");

    ofstream out_file;
    out_file.open("outFile.txt");

    char ptr[MAX_OF_LINE];
    for (int i=0; i<MAX_OF_LINE;i++)
        ptr[i]='\0';
    while(in_file.getline(ptr,MAX_OF_LINE))
    {
        string str=ptr;
        if ((str.find("**id = ")<str.size()) && (!isMappedCounter(str)) )
            str=str.substr(0,str.find("**id = "));
        out_file << str << endl;
        cout << str << endl;
    }
    in_file.close();
    out_file.close();
}

BOOL isSpaceOrTab(const string& str)
{
    char ch_space = ' ';
    char ch_tab = '\b';
    size_t i=0;
    while (i<str.length())
    {
        if ((str[i] != ch_space) && (str[i] != ch_tab))
            return false;
        i++;
    }
    return true;
}

void removeSpace(void)
{
    ifstream in_file;
    in_file.open("./outFile.txt");

    ofstream out_file;
    out_file.open("outFileWithNoSpace.txt");

    char ptr[MAX_OF_LINE];
    for (int i=0; i<MAX_OF_LINE;i++)
        ptr[i]='\0';
    while(in_file.getline(ptr,MAX_OF_LINE))
    {
        string str=ptr;
        out_file << str << endl;
        cout << str << endl;

        while (isSpaceOrTab(str))
        {
            in_file.getline(ptr,MAX_OF_LINE);
            str = ptr;
            if (isSpaceOrTab(str))
                continue;
            out_file << str << endl;
            cout << str << endl;
            break;
        }
    }
    in_file.close();
    out_file.close();
}

int main()
{
    setFile();
    removeSpace();
    system("pause");
    return 0;
}

xlyz.os 2009-02-18 23:53 发表评论

根据先序遍历和中序遍历创建二叉树

xlyz.os — Tue, 10 Feb 2009 14:22:00 GMT

  1 #include <iostream>
  2 #include <vector>
  3 using namespace std;
  4
  5 class BiTree
  6 {
  7 private:
  8     struct NODE
  9     {
10         int data;
11         NODE* left_child;
12         NODE* right_child;
13
14         NODE(int data, NODE* left, NODE* right)
15         {
16             this->data = data;
17             this->left_child = left;
18             this->right_child = right;
19         }
20     };
21
22     NODE* root;
23
24     //first 和 middle 分别是同一颗二叉树的先序遍历和中序遍历  first和middle不能为空
25     NODE* getRootNode(const vector<int> &first, const vector<int> &middle )
26     {
27         vector<int> left_child_of_first;
28         vector<int> left_child_of_middle;
29         vector<int> right_child_of_first;
30         vector<int> right_child_of_middle;
31
32         int data_ = first[0];
33
34         vector<int>::const_iterator iter_target;
35         for (iter_target = middle.begin(); iter_target != middle.end(); ++iter_target)
36             if (data_ == (*iter_target))
37                 break;
38
39         for (vector<int>::const_iterator it = middle.begin(); it != iter_target; ++it)
40             left_child_of_middle.push_back(*it);
41         for (vector<int>::const_iterator it = iter_target+1; it != middle.end(); ++it)
42             right_child_of_middle.push_back(*it);
43
44         vector<int>::const_iterator it = first.begin() + 1;
45         while (left_child_of_first.size() < left_child_of_middle.size())
46         {
47             left_child_of_first.push_back(*it);
48             it++;
49         }
50
51         while (right_child_of_first.size() < right_child_of_middle.size())
52         {
53             right_child_of_first.push_back(*it);
54             it++;
55         }
56
57         NODE* ptr;
58         if (1 == first.size())
59             return ptr = new NODE(data_, 0, 0);
60
61         if ((0 == left_child_of_first.size())&&(0 != right_child_of_first.size()))
62             return ptr = new NODE(data_, 0 ,getRootNode(right_child_of_first, right_child_of_middle));
63         else if ((0 != left_child_of_first.size())&&(0 == right_child_of_first.size()))
64             return ptr = new NODE(data_, getRootNode(left_child_of_first, left_child_of_middle), 0);
65         else
66             return ptr = new NODE(data_, getRootNode(left_child_of_first, left_child_of_middle), getRootNode(right_child_of_first, right_child_of_middle));
67         //等效于上面的return语句,不过对于上面的语句，不同的编译器，getRootNode的计算顺序并不相同，在VS2003上，先调用后面的getRootNode函数
68         /*
69         {
70             NODE* p_left;
71             NODE* p_right;
72             p_left = getRootNode(left_child_of_first, left_child_of_middle);
73             p_right = getRootNode(right_child_of_first, right_child_of_middle);
74
75             return ptr = new NODE(data_, p_left, p_right);
76         }
77         */
78     }
79
80     //释放内存
81     void delete_ptr(NODE* p)
82     {
83         if (p->left_child)
84             delete p->left_child;
85         if (p->right_child)
86             delete p->right_child;
87         delete p;
88     }
89
90     //打印后序遍历
91     void last_display(NODE* p)
92     {
93         if (p->left_child && p->right_child)
94         {
95             last_display(p->left_child);
96             last_display(p->right_child);
97             cout << (p->data) << "----";
98         }
99         if (p->left_child && (!p->right_child))
100         {
101             last_display(p->left_child);
102             cout << (p->data) << "----";
103         }
104         if (! p->left_child && (p->right_child))
105         {
106             last_display(p->right_child);
107             cout << (p->data) << "----";
108         }
109         if (!(p->left_child) && !(p->right_child))
110             cout << (p->data) << "----";
111     }
112
113 public:
114
115     //构造函数(用先序遍历和中序遍历构造一个二叉树)
116     BiTree()
117     {
118         cout << "input the number of the bitree:";
119         int n=0;
120         cin >> n;
121
122         cout << "input first sort:";
123         vector<int> first;
124         int data_;
125         for (int i=0; i < n; ++i)
126         {
127             cin >> data_;
128             first.push_back(data_);
129         }
130
131         cout << "input middle sort";
132         vector<int> middle;
133         for (int i=0; i < n; ++i)
134         {
135             cin >> data_;
136             middle.push_back(data_);
137         }
138
139         root = getRootNode(first, middle);
140     }
141
142     void display()
143     {
144         NODE* p = root;
145         last_display(p);
146     }
147
148     //析构函数
149     ~BiTree()
150     {
151         delete_ptr(root);
152     }
153 };
154
155 int main()
156 {
157     BiTree bitree;
158     bitree.display();
159     system("PAUSE");
160     return 0;
161 }

xlyz.os 2009-02-10 22:22 发表评论