C++博客-小乌龟-随笔分类-C&C++

为什么复制构造函数的参数必须为引用

小乌龟 — Sun, 22 Apr 2012 16:21:00 GMT

为什么复制构造函数的参数必须为引用呢，原因如下：

Because if it's not by reference, it's by value. To do that you make a copy, and to do that you call the copy constructor. But to do that, we need to need to make a new value, so we call the copy constructor, and so on...

(You would have infinite recursion because "to make a copy, you need to make a copy".)

来源：

http://stackoverflow.com/questions/2685854/why-should-the-copy-constructor-accept-its-parameter-by-reference-in-c

老忘记，举个例子也许更好理解：

//创建Type类型的对象a
Type a;

//对a的对象内部数据成员赋值

// 调用复制构造函数创建对象b
Type b( a )

由于b的复制构造函数的参数被定义为值传递，那么首先会创建一个Type的临时变量，假设为temp1，然后再传递给b的复制构造函数

Type temp1( a )

由于temp1的复制构造函数的参数被定义为值传递，那么首先会创建一个Type的临时变量，假设为temp2，然后再传递给b的复制构造函数

Type temp2( a )

类推,会出现temp3,temp4,...直至无穷多！

所以复制构造函数的参数必须为引用

小乌龟 2012-04-23 00:21 发表评论

C语言获取文件大小

小乌龟 — Fri, 22 Oct 2010 03:22:00 GMT

今天去面试，面试官问了个C中如何获取文件大小，想啊想，没有这个函数啊。那应该是用fseek将文件指针移动到文件末尾，然后通过文件指针获取吧？但是什么函数呢，没印象，汗......
回来查了下，原来是ftell，悲剧啊，以前没用过！MSDN上ftell的功能如下：Gets the current position of a file pointer。写了段代码测试了下，代码如下：

#include <stdio.h>

int main()
{
    long fileSize = 0;

    FILE* pFile = fopen( "mm.data", "r" );
    if ( pFile == NULL )
    {
        printf( "Open File Error\n" );
    }
    else
    {
        // 将指针定位到文件末尾
        fseek( pFile, 0L, SEEK_END );
        fileSize = ftell( pFile );

        printf( "file size: %ld\n", fileSize );
    }
    return 0;
}

小乌龟 2010-10-22 11:22 发表评论

string中的+, =, +=

小乌龟 — Sun, 23 Nov 2008 08:14:00 GMT

看一段简单的代码：

int main()
{
    string s;
    s += 'a';
    s += "bc";
    cout << "s: " << s << endl;

    cout << endl;
    system("Pause");
    return 0;
}

对不？当然对的！参看basic_string.h中的源码：

      basic_string&
      operator+=(const basic_string& __str) { return this->append(__str); }

      /**
       *  @brief  Append a C string.
       *  @param s  The C string to append.
       *  @return  Reference to this string.
       */
      basic_string&
      operator+=(const _CharT* __s) { return this->append(__s); }

      /**
       *  @brief  Append a character.
       *  @param s  The character to append.
       *  @return  Reference to this string.
       */
      basic_string&
      operator+=(_CharT __c) { return this->append(size_type(1), __c); }

下面的代码对不？

    string s1;
    s1 = 'a';    // = 也定义了右边的值为字符的情况
    cout << "s1: " << s1 << endl;
    s1 = "bc";
    cout << "s1: " << s1 << endl;

看源码！

      basic_string&
      operator=(const basic_string& __str)
      {
    this->assign(__str);
    return *this;
      }

      /**
       *  @brief  Copy contents of @a s into this string.
       *  @param  s  Source null-terminated string.
       */
      basic_string&
      operator=(const _CharT* __s)
      {
    this->assign(__s);
    return *this;
      }

      /**
       *  @brief  Set value to string of length 1.
       *  @param  c  Source character.
       *
       *  Assigning to a character makes this string length 1 and
       *  (*this)[0] == @a c.
       */
      basic_string&
      operator=(_CharT __c)
      {
    this->assign(1, __c);
    return *this;
      }

下面的呢

    string s2("u");
    s2 = 'j' + s2;
         cout << "s2: " << s2 << endl;
    s2 = s2 + 'n';
    cout << "s2: " << s2 << endl;
    s2 = "jin " + s2;
    cout << "s2: " << s2 << endl;
    s2 = s2 + " xia";
    cout << "s2: " << s2 << endl;

还是源码！

// operator+
  /**
   *  @brief  Concatenate two strings.
   *  @param lhs  First string.
   *  @param rhs  Last string.
   *  @return  New string with value of @a lhs followed by @a rhs.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
          const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  /**
   *  @brief  Concatenate C string and string.
   *  @param lhs  First string.
   *  @param rhs  Last string.
   *  @return  New string with value of @a lhs followed by @a rhs.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
          const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  /**
   *  @brief  Concatenate character and string.
   *  @param lhs  First string.
   *  @param rhs  Last string.
   *  @return  New string with @a lhs followed by @a rhs.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  /**
   *  @brief  Concatenate string and C string.
   *  @param lhs  First string.
   *  @param rhs  Last string.
   *  @return  New string with @a lhs followed by @a rhs.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
         const _CharT* __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  /**
   *  @brief  Concatenate string and character.
   *  @param lhs  First string.
   *  @param rhs  Last string.
   *  @return  New string with @a lhs followed by @a rhs.
   */
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
      typedef typename __string_type::size_type        __size_type;
      __string_type __str(__lhs);
      __str.append(__size_type(1), __rhs);
      return __str;
    }

也许，最好的资料就是看看头文件或者源码！

小乌龟 2008-11-23 16:14 发表评论

两次CTRL+Z才能中止程序

小乌龟 — Sun, 26 Oct 2008 08:34:00 GMT

#include <stdio.h>

main()
{
    char c;
    while (scanf("%c", &c) != EOF)
    {
        printf("%c", c);
    }
    return 0;
}

一段很让人不爽的代码，为什么要输入两次Ctrl+Z呢。只能说是VC6.0和C-Free的bug, 谁知道了告诉我一声。其他人的讨论：
http://topic.csdn.net/u/20080429/22/dcd3aba2-0cad-4c56-aeb2-2be7d3b07d44.html

小乌龟 2008-10-26 16:34 发表评论

cout << &("abc") << endl解析

小乌龟 — Mon, 08 Sep 2008 17:27:00 GMT

ChinaUnix上看到有人问了一个问题,程序代码如下:

cout << &("abc") << endl; // 输出abc
cout << &(&("abc")) << endl; // 输出abc
cout << &(&(&("abc"))) << endl;
// 输出abc，好像无论在"abc"前加几个&，输出都为abc

   一个人的评价:
   数组char str[]在内存中存储方式:str和&str是同一个值,也就是说str本身在内存中没有占用空间,str、&str和&str[0]的值是一样的，只是直接给str[]的数组元素分配了空间。指针char *str在内存中的存储方式：首先会给str变量本身分配空间，也就是说str和&str的值肯定是不一样的，&str就是str的地址，在指针初始化后才给指针char *str所指向的字符串明确的分配空间，当然这个空间的首地址就是str的值。所以数组和指针还是有区别的，只是编译器对指针的处理是按照处理数组的方式来处理的。
  这个评价真的是那么正确吗?
   先分析代码:三个输出一样,是因为:取地址运算符只能用于内存中的对象,即变量和数组元素.它不能作用于表达式,常量或register类型的变量(The C Programming Language P93).
   那么字符串常量的返回值是什么呢?是指针变量吗?不像!有人说:怎么不像了,当你把一个字符串常量作为一个参数传递给函数,其行为就像指针啊.那就想想数组,将数组名传递给函数,它的行为也像指针啊.可数组名终究不是指针,只不过作为函数参数时,其退化为了指针.是不是像数组,的确有那种味道.不信就看看下面的测试代码:

#include <stdio.h>

main(int argc, char *argv[])
{
    char *p  = "xiexiu";
    char s[] = "xiexiu";

    printf("%u\n", sizeof "xiexiu");
    printf("%u\n", sizeof p);
    printf("%u\n", sizeof s);
    return 0;
}

   输出结果时:
   7
   4
   7
   既然这样的话,那么数组名是变量还是常量呢?数组名实质上是这个数组的首地址，一旦系统开辟了这块内存，那么这个内存的首地址就不能改变，所以，对数组名的赋值肯定是不允许的。数组名等同于常量，但是还有没有数组名就是常量的说法。这就说明了数组名绝不是变量,当然也不是数组元素了.因此对数组名取地址,要么是未定义,要么是非法的.对字符串常量取地址,很多编译器都可以通过,只是警告一番.因此对于数组str[],str和&str是同一个值的说法是不对,因为&str这个本身不合法或未定义的.
   还有他说:所以数组和指针还是有区别的，只是编译器对指针的处理是按照处理数组的方式来处理的。数组当然和指针有区别了.数组名不是变量,而指针是.编译器对指针的处理是按照处理数组的方式来处理的吗?那么为什么用指针编写的程序比数组的快?
   The C Programming Language P98:在计算数组元素a[i]的值时,C语言实际上先将其转换为*(a+i)的形式,然后再进行求值,这就说明了编译器对数组的处理是按照指针的方式来处理的.同时也说明了为什么用指针编写的程序比用数组编写的快.

小乌龟 2008-09-09 01:27 发表评论

C-Free对程序命令行参数*的处理

小乌龟 — Sat, 06 Sep 2008 03:42:00 GMT

用C-Free(使用默认的mingw编译器)编译一个程序的时候,出现了一个古怪的现象.MS如果一个程序有命令行参数且命令行参数中含有*,则编译器就会将*替换为本目录下的所有文件名,而用VC++6.0则不会出现以上的情况.

测试了一番,的确如此.程序代码如下:

/* 包含头文件 */
#include <stdio.h>

main(int argc, char *argv[])
{
    while (argc-- > 0)
    {
        printf("%s\n", *argv++);
    }
    return 0;
}

   用C-Free4.0(使用默认的mingw编译器)编译成expr.exe.然后将其放置于一个文件夹下,此时文件夹里含有两个文件:expr.exe和expr.txt.从命令行执行: expr.exe *,结果显示:
   expr.exe
   expr.exe
   expr.txt

   用VC++6.0编译成expr2.exe,然后将它移到此文件夹下,执行同样的命令: expr.exe *,结果如下:
   expr2.exe
   *

   如果*不是作为一个单独的参数,而是作为一个参数的一部分,情况会怎样,执行命令:expr.exe 1*2,结果如下:
   expr.exe
   1*2
   因此,在使用C-Free(默认编译器mingw)编译含有*命令行参数的程序,务必小心.

小乌龟 2008-09-06 11:42 发表评论

给int赋最小值问题

小乌龟 — Fri, 01 Aug 2008 08:40:00 GMT

int n = -2147483648;

        如此简单的一句代码，居然出现了警告？-2147483648是32位int类型可以存储的最小整型值，为什么会出项警告呢。在VC++6.0控制台程序下出现如下警告：warning C4146: unary minus operator applied to unsigned type, result still unsigned。在C-Free中出现：c:55: warning: decimal constant is so large that it is unsigned。

        上网查了下，发现了原因：
        一元负运算符应用于无符号类型，结果仍为无符号类型。无符号类型只能保存非负值，所以一元负（非）应用于无符号类型时通常无意义。操作数和结果都是非负的。
        实际上，当程序员试图表达最小整数值-2147483648 时，发生此问题。该值不能写为-2147483648，因为表达式处理分两个步骤：
        计算数字2147483648。因为2147483648 大于最大整数值2147483647，所以其类型不是int，而是unsigned int。
        将一元负应用于该值，得到无符号结果，该结果碰巧是 2147483648。无符号类型的结果可能导致意外行为。如果在比较中使用该结果，则可使用无符号比较，而不能出现另一个操作数是 int 时。这解释了下面的示例程序只输出一行的原因。
        预期的第二行为：1 is greater than the most negative int，但未输出，因为((unsigned int)1) > 2147483648为假。

#include

main()
{

    check(-10);
    check(1);

    return 0;
}

void check(int i)
{
    if (i > -2147483648)
    printf("%d is greater than the most negative int\n", i);
}

        输出结果：

        上面的解释省略了一些细节，我来补充下。在if (i > -2147483648)中，由于i为int类型，而-2147483648为unsigned int类型，所有i就会被提升为unsigned int类型，这就是C语言的整型提升。-10提升为unsigned int类型后，其值肯定会大于2147483648，因此第一条语句会打印出来。当把正整数（比如本实验中的1）提升为unsigned int类型时，其值是不变的，因此肯定比2147483648要小，所有第二条语句不会打印。

      那如何来解决这个可恶的警告呢。网上说：可以通过从 Limits.h 使用INT_MIN(一个宏定义) 来避免C4146 警告。INI_MIN宏有如何的魔力，竟然能够消除这个警告呢。打开源文件一看，原来是这样：

#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX-1)

哦，原来这样。因此，我们又可以这样赋值最小负整数：

int n = -2147483647 - 1;

小乌龟 2008-08-01 16:40 发表评论

C/C++中的枚举

小乌龟 — Tue, 29 Jul 2008 07:35:00 GMT

读K&R的The C Programmingh Language 2nd，遇到一疑问，书中说：“尽管可以声明enum类型的变量，但编译器不检查这种类型的变量中存储的值是否为该枚举的有效值。不过，枚举变量提供这种检查，因此枚举比#define更具优势。”
枚举变量提供这种检查，什么意思？枚举变量会自己检？当然不是，作者也许想说程序员自己可以写个程序检查付给枚举变量的值是否为该枚举的有效值。

/* 包含头文件 */
#include <stdio.h>

/* 枚举类型 */
enum months{JAN = 1, FEB};

/* 函数原型 */
void enumeration(enum months m);

main()
{
    enum months a = 2;
    enum months b = 50;        /* C中不需要强制转换为enum months类型 */

    enum months c = JAN;

    enumeration(a);
    enumeration(b);

    return 0;
}

/* enumeration函数：检测枚举变量存储的值是否为该枚举的有效值 */
void enumeration(enum months m)
{
    switch (m)
    {
    case JAN:
        printf("JAN: %d\n", JAN);
        break;

    case FEB:
        printf("FEB: %d\n", FEB);
        break;

    default:
        printf("%d不是该枚举的有效值！\n", m);
        break;
    }
}

而这段代码如果改为C++源文件编译，却不能通过。原因如下：

根据C标准的规定，枚举常量的类型为int，枚举变量的类型应该与char、有符号或无符号整型兼容。因此，枚举变量可以接受 char、有符号或无符号整型数，而不限于仅从此枚举类型所定义的枚举常量中取值。由于上述原因，在C語言中无法从語法上保证枚举变量只能在定义的枚举成员中取值，只能由程序员自身保证不使用除枚举成员之外的值。

关于這一点，很多介绍C语言的书上或者资料上的描述是不正确的，应该加以注意。

但是，如果给枚举变量赋枚举成员之外的值，有的编译器可能会对此产生警告，有的则不會。因为这种行为不违反C标准的规定，编译器对此如何反应都是有道理的。

然而对于C++来说，编译器会禁止给枚举变量赋予枚举成员之外的值。这是因为C++是一种强类型语言，枚举类型不等同于 int 等其它类型。虽然枚举类型可以隐式转化为 int 等类型，但是 int 等类型却不能自动转化为枚举类型，除非使用强制类型转化。因此，如果不使用强制类型转化的话，给枚举变量赋值则只能从枚举成员中选择。对于枚举类型要避免使用强制类型转换。原因如下：

The C++ Programming Language上说:
如果某个枚举中所有枚举值非负,枚举的表示范围为[0 : 2^k-1];其中2^K是使所有枚举成员位于此范围内的最小的2的幂;如果是负的,就是[-2^k : 2^k-1]。因此对一个给定的整数值，如果使用强制类型转换，而其值又不在枚举的表示范围以内，其行为是未定义的。

// 包含头文件
#include <iostream.h>

int main()
{
    enum months{JAN = 1, FEB, MAR};

    //enum months a = 1;              //cannot convert from 'const int' to 'enum main::months'
    enum months a = (enum months)1;
    cout << "a: " << a << endl;    //输出: a: 1

    enum months b = (enum months)10;
    cout << "b: " << b << endl;    //输出: b: 10 虽然输出10，但结果是未定义的，因为此枚举的表示范围为：0～3

    return 0;
}

小乌龟 2008-07-29 15:35 发表评论

C中运算符结合性

小乌龟 — Mon, 28 Jul 2008 11:44:00 GMT

什么是运算符的结合性？

当两个运算符的优先级一样的时候，先算哪一个的问题，这就是结合性。

首先要明白的是：结合性对于两个或两个以上的优先级一样的运算符才有意义。
比如：

m = x + y - z;

由于算术运算符的结合性是从左至右，因此上式等价于：

m = (x + y) - z;

再比如：

#include <stdio.h>

main()
{
    int s[2] = {11, 52};
    int *ptr = s;

    printf("%d\n", *++ptr);
    return 0;
}

答案是：52
由于*和++的结合性从右至左，因此*++ptr等价于*(++ptr)

在网上查询资料的时候发现：很多人问条件运算符的结合性的问题。

int i = 3;
int k = 0;

k = (i++<0) ? 9 : ((i==3) ? 10 : 8);

cout <<k;

k = (3<0)?9:((i==3)?10:8);
之后i变成4
----〉
3<0是假，所以k不为9，继续计算下一步。
k = ((i==3)?10:8);
----〉
我们知道这时候i等于4，所以，((i==3)为假。
所以k不等于10，而是等于8嘛
k = ((i==3)?10:8);
----〉
k = 8

有人问，那条件运算符的结合性且不是从左至右了，这与书上写的从右至左不符？
其实上面根本牵涉不到什么结合性的问题，只有一个运算符会牵涉到结合性吗。而条件运算符是C中规定计算顺序的四个运算符之一，因此上面的计算顺序是完全正确的。

小乌龟 2008-07-28 19:44 发表评论