公告

// CodeData.h : 编码数据列表及宏定义
//

#if !defined(CODEDATA_H__126F56F0_FED9_11D1_A3AE_0000B4312379__INCLUDED_)
#define CODEDATA_H__126F56F0_FED9_11D1_A3AE_0000B4312379__INCLUDED_

/////////////////////////////////////////////////////////////////////////////
//编码列表 CCodeList

class CCodeList
{
public:
    CCodeList(int NexrOffset = 0);
    void Construct(int nNextOffset);

//Operations
    BOOL IsEmpty() const;
    void AddHead(void *p);
    BOOL Remove(void *p);
    void RemoveAll();
    void *GetHead() const;
    void *GetNext(void *p) const;

//Implementation
    void *m_pHead;
    size_t m_nNextOffset;

    void **GetNextPtr(void *p) const;
};

inline CCodeList::CCodeList(int nNextOffset)
        { m_pHead = NULL; m_nNextOffset = nNextOffset; }
inline void CCodeList::Construct(int nNextOffset)
        { ASSERT(m_pHead == NULL); m_nNextOffset = nNextOffset; }
inline BOOL CCodeList::IsEmpty() const
        { return m_pHead == NULL; }
inline void **CCodeList::GetNextPtr(void *p) const
        { ASSERT(p != NULL); return (void**)((BYTE*)p+m_nNextOffset); }
inline void CCodeList::RemoveAll()
        { m_pHead = NULL; }
inline void *CCodeList::GetHead() const
        { return m_pHead; }
inline void *CCodeList::GetNext(void *prevElement) const
        { return *GetNextPtr(prevElement); }


/////////////////////////////////////////////////////////////////////////////
//编码列表模板

template<class TYPE>
class CTypedCodeList : public CCodeList
{
public:
    CTypedCodeList(int nNextOffset = 0) : CCodeList(nNextOffset) 
            { }
    void AddHead(TYPE p) 
            { CCodeList::AddHead(p); }
    TYPE GetHead() 
            { return (TYPE)CCodeList::GetHead(); }
    TYPE GetNext(TYPE p) 
            { return (TYPE)CCodeList::GetNext(p); }
    BOOL Remove(TYPE p) 
            { return CCodeList::Remove((TYPE)p); }
    operator TYPE() 
            { return (TYPE)CCodeList::GetHead(); }
};


////////////////////////////////////////////////////////////////////////////

class CCodeData
{
public:
    CCodeData *pNext;

// Constructor
    CCodeData();

// Attributes
public:
    CString    strCode;        //编码
    CString    strName;        //简称
    CString    string1;        //全称或标志1
    CString string2;        //标志2
    DOUBLE    dValue;            //值
    INT        nValue;            //值

// Implementation
public:
    CString& GetCode() { return strCode; }
    CString& GetName() { return strName; }
    CString& GetString1() { return string1; }
    CString& GetString2() { return string2; }
    DOUBLE     GetValue() { return dValue; }

    virtual ~CCodeData() {};
};


/////////////////////////////////////////////////////////////////////////////
//各类编码表数据结构定义

typedef struct _FIELD_NAME
{
    LPCTSTR lpszCode;
    LPCTSTR lpszName;
    LPCTSTR lpszField1;
    LPCTSTR lpszField2;
    LPCTSTR lpszField3;
} FIELD_NAME;

typedef struct _RECORDSET_DATA
{
    UINT        nID;
    LPCSTR        lpszTableName;
    INT            nFields;
    LPCSTR        lpszFilter;
    FIELD_NAME    field;
} CODESETSTRUCT;



////////////////////////////////////////////////////////////////////////////
//

#define CODE_FIRST        0        
#define CODE_LAST        7        //版本1 仅支持8个编码表
#define CODESET_NUMBER    8        //8个编码表

#define CODE_ZY         0        //摘要码
#define CODE_KM         1        //科目编码
#define CODE_BM         2        //部门编码
#define CODE_RY         3        //人员编码
#define CODE_DW         4        //往来单位编码
#define CODE_SP         5        //商品编码
#define CODE_JS         6        //结算方式编码
#define CODE_WB         7        //外币编码
#define CODE_ZC         8        //资产编码
#define CODE_CK         9        //仓库编码



/////////////////////////////////////////////////////////////////////////////
#endif // !defined(CODEDATA_H__126F56F0_FED9_11D1_A3AE_0000B4312379__INCLUDED_)

C++引用10分钟入门教程

< C++引用C++引用在本质上是什么，它和指针到底有什么区别？ >

我们知道，参数的传递本质上是一次赋值的过程，赋值就是对内存进行拷贝。所谓内存拷贝，是指将一块内存上的数据复制到另一块内存上。

对于像 char、bool、int、float 等基本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝非常快速。而数组、结构体、对象是一系列数据的集合，数据的数量没有限制，可能很少，也可能成千上万，对它们进行频繁的内存拷贝可能会消耗很多时间，拖慢程序的执行效率。

C/C++ 禁止在函数调用时直接传递数组的内容，而是强制传递数组指针，这点已在《C语言指针变量作为函数参数》中进行了讲解。而对于结构体和对象没有这种限制，调用函数时既可以传递指针，也可以直接传递内容；为了提高效率，我曾建议传递指针，这样做在大部分情况下并没有什么不妥，读者可以点击《C语言结构体指针》进行回顾。

但是在 C++ 中，我们有了一种比指针更加便捷的传递聚合类型数据的方式，那就是引用（Reference）。

在 C/C++ 中，我们将 char、int、float 等由语言本身支持的类型称为基本类型，将数组、结构体、类（对象）等由基本类型组合而成的类型称为聚合类型（在讲解结构体时也曾使用复杂类型、构造类型这两种说法）。

引用（Reference）是 C++ 相对于C语言的又一个扩充。引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式，一个可执行程序可以有多个快捷方式，通过这些快捷方式和可执行程序本身都能够运行程序；引用还类似于人的绰号（笔名），使用绰号（笔名）和本名都能表示一个人。

引用的定义方式类似于指针，只是用&取代了*，语法格式为：

type &name = data;

type 是被引用的数据的类型，name 是引用的名称，data 是被引用的数据。引用必须在定义的同时初始化，并且以后也要从一而终，不能再引用其它数据，这有点类似于常量（const 变量）。

下面是一个演示引用的实例：

#include <iostream>
using namespace std;
int main() {
int a = 99;
int &r = a;
cout << a << ", " << r << endl;
cout << &a << ", " << &r << endl;
return 0;
}

运行结果：
99, 99
0x28ff44, 0x28ff44

本例中，变量 r 就是变量 a 的引用，它们用来指代同一份数据；也可以说变量 r 是变量 a 的另一个名字。从输出结果可以看出，a 和 r 的地址一样，都是0x28ff44；或者说地址为0x28ff44的内存有两个名字，a 和 r，想要访问该内存上的数据时，使用哪个名字都行。

注意，引用在定义时需要添加&，在使用时不能添加&，使用时添加&表示取地址。如上面代码所示，第 6 行中的&表示引用，第 8 行中的&表示取地址。除了这两种用法，&还可以表示位运算中的与运算。

由于引用 r 和原始变量 a 都是指向同一地址，所以通过引用也可以修改原始变量中所存储的数据，请看下面的例子：

#include <iostream>
using namespace std;
int main() {
int a = 99;
int &r = a;
r = 47;
cout << a << ", " << r << endl;
return 0;
}

运行结果：
47, 47

最终程序输出两个 47，可见原始变量 a 的值已经被引用变量 r 所修改。

如果读者不希望通过引用来修改原始的数据，那么可以在定义时添加 const 限制，形式为：

const type &name = value;

也可以是：

type const &name = value;

这种引用方式为常引用

C++引用作为函数参数

在定义或声明函数时，我们可以将函数的形参指定为引用的形式，这样在调用函数时就会将实参和形参绑定在一起，让它们都指代同一份数据。如此一来，如果在函数体中修改了形参的数据，那么实参的数据也会被修改，从而拥有“在函数内部影响函数外部数据”的效果。

至于实参和形参是如何绑定的，我们将在下节《C++引用在本质上是什么，它和指针到底有什么区别？》中讲解，届时我们会一针见血地阐明引用的本质。

一个能够展现按引用传参的优势的例子就是交换两个数的值，请看下面的代码：

#include <iostream>
using namespace std;
void swap1(int a, int b);
void swap2(int *p1, int *p2);
void swap3(int &r1, int &r2);
int main() {
int num1, num2;
cout << "Input two integers: ";
cin >> num1 >> num2;
swap1(num1, num2);
cout << num1 << " " << num2 << endl;
cout << "Input two integers: ";
cin >> num1 >> num2;
swap2(&num1, &num2);
cout << num1 << " " << num2 << endl;
cout << "Input two integers: ";
cin >> num1 >> num2;
swap3(num1, num2);
cout << num1 << " " << num2 << endl;
return 0;
}
//直接传递参数内容
void swap1(int a, int b) {
int temp = a;
a = b;
b = temp;
}
//传递指针
void swap2(int *p1, int *p2) {
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
//按引用传参
void swap3(int &r1, int &r2) {
int temp = r1;
r1 = r2;
r2 = temp;
}

运行结果：
Input two integers: 12 34↙
12 34
Input two integers: 88 99↙
99 88
Input two integers: 100 200↙
200 100

本例演示了三种交换变量的值的方法：
1) swap1() 直接传递参数的内容，不能达到交换两个数的值的目的。对于 swap1() 来说，a、b 是形参，是作用范围仅限于函数内部的局部变量，它们有自己独立的内存，和 num1、num2 指代的数据不一样。调用函数时分别将 num1、num2 的值传递给 a、b，此后 num1、num2 和 a、b 再无任何关系，在 swap1() 内部修改 a、b 的值不会影响函数外部的 num1、num2，更不会改变 num1、num2 的值。

2) swap2() 传递的是指针，能够达到交换两个数的值的目的。调用函数时，分别将 num1、num2 的指针传递给 p1、p2，此后 p1、p2 指向 a、b 所代表的数据，在函数内部可以通过指针间接地修改 a、b 的值。我们在《C语言指针变量作为函数参数》中也对比过第 1)、2) 中方式的区别。

2) swap3() 是按引用传递，能够达到交换两个数的值的目的。调用函数时，分别将 r1、r2 绑定到 num1、num2 所指代的数据，此后 r1 和 num1、r2 和 num2 就都代表同一份数据了，通过 r1 修改数据后会影响 num1，通过 r2 修改数据后也会影响 num2。

从以上代码的编写中可以发现，按引用传参在使用形式上比指针更加直观。在以后的 C++ 编程中，我鼓励读者大量使用引用，它一般可以代替指针（当然指针在C++中也不可或缺），C++ 标准库也是这样做的。

C++引用作为函数返回值

引用除了可以作为函数形参，还可以作为函数返回值，请看下面的例子：

#include <iostream>
using namespace std;
int &plus10(int &r) {
r += 10;
return r;
}
int main() {
int num1 = 10;
int num2 = plus10(num1);
cout << num1 << " " << num2 << endl;
return 0;
}

运行结果：
20 20

在将引用作为函数返回值时应该注意一个小问题，就是不能返回局部数据（例如局部变量、局部对象、局部数组等）的引用，因为当函数调用完成后局部数据就会被销毁，有可能在下次使用时数据就不存在了，C++ 编译器检测到该行为时也会给出警告。

更改上面的例子，让 plus10() 返回一个局部数据的引用：

#include <iostream>
using namespace std;
int &plus10(int &r) {
int m = r + 10;
return m; //返回局部数据的引用
}
int main() {
int num1 = 10;
int num2 = plus10(num1);
cout << num2 << endl;
int &num3 = plus10(num1);
int &num4 = plus10(num3);
cout << num3 << " " << num4 << endl;
return 0;
}

在 Visual Studio 下的运行结果：

20
-858993450 -858993450

在 GCC 下的运行结果：

20
30 30

在 C-Free 下的运行结果：

20
30 0

而我们期望的运行结果是：

20
20 30

plus10() 返回一个对局部变量 m 的引用，这是导致运行结果非常怪异的根源，因为函数是在栈上运行的，并且运行结束后会放弃对所有局部数据的管理权，后面的函数调用会覆盖前面函数的局部数据。本例中，第二次调用 plus10() 会覆盖第一次调用 plus10() 所产生的局部数据，第三次调用 plus10() 会覆盖第二次调用 plus10() 所产生的局部数据。

关于函数调用的内部实现，我已在《C语言内存精讲》专题中讲到。

C++ : 仅添加一个引用& 竟就导致程序崩溃！

七昂的技术之旅

浙江大学计算机技术硕士

收录于 · C++编程系列

23 人赞同了该文章

问题描述

在项目某次开发中，测试过程中出现了coredump问题。经过asan工具检测，报了heap-use-after-free内存错误，最终定位到竟是无意中添加了一个引用&导致的！

开发时因为看到相关类访问类成员的接口函数未返回引用，而是返回了一个拷贝，因此想着要将返回值改为引用，避免多余的拷贝。例如在以下代码中，我们将GetArr函数的返回值改为引用：

class Foo {
private:
    std::vector<int> arr;
public:
    std::vector<int>& GetArr() {  // add & for return type
        return arr;
    }
    // other functions
};

看起来这并没什么问题，但是在多线程环境下，加一个&可能就会导致程序崩溃。

问题分析

比如以下代码展示了一个简单的例子，表面看起来GetArr是有锁保护的，但实际上锁保护被打破了：

class Foo {
private:
    std::vector<int> arr;
    std::mutex mut;
public:
    std::vector<int>& GetArr() {
        std::lock_gurad<std::mutex> lk(mut);
        return arr;
    }
    // other functions
};

为什么呢？GetArr返回一个 vector 的引用，然后立即释放锁。因此，返回的引用可以在没有任何保护的情况下被修改。当多个线程对同一个Foo实例的arr进行读写时，就会导致数据竞争，从而导致程序崩溃的风险。

如何避免？

对于类对象的多线程共享数据，访问接口应返回拷贝而不是引用。

std::vector<int> GetArr() {  // return a copy
    return arr;
}

总结

再翻翻《C++并发实战》，才发现书中已经总结了这个陷阱：通常来说，类的所有成员函数在访问任何数据成员之前，假如都先对互斥加锁，并在完成访问后解锁，共享数据就可很好地受到全方位保护。可惜事与愿违：如果类的成员函数返回指向共享数据的指针或引用，那么这些数据就会在锁外被访问，从而破坏了互斥的效果。

因此，我们可以总结一个规则：不得向锁所在的作用域之外传递指针和引用，指向受保护的共享数据，无论是通过函数返回值将它们保存到对外可见的内存，还是将它们作为参数传递给使用者提供的函数。

参考

1. C++ Concurrency in Action, Anthony Williams

你好，我是七昂，致力于分享C++、计算机底层、机器学习等系列知识。希望我们能一起探索程序员修炼之道。如果我的创作内容对您有帮助，请点赞关注。如果有问题，欢迎随时与我交流。感谢你的阅读。

所属专栏 · 2024-12-30 00:36 更新

C++编程系列

七昂的技术之旅

浙江大学计算机技术硕士

18 篇内容 · 751 赞同

最热内容 ·

万字长文全面详解现代C++智能指针：原理、应用和陷阱

编辑于 2024-05-19 17:46・上海

C++

Modern C++

C / C++

理性发言，友善互动

25 条评论

默认

不及格的程序员-八神