国内精品久久久久久麻豆,看全色黄大色大片免费久久久 ,久久精品国产免费观看三人同眠

Sun, 22 Apr 2012 16:21:00 GMT

��Z��么复制构造函数的参数必须为引用呢�Q�原因如下：(x��)

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".)

来源�Q?br />

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

老忘讎ͼ�举个例子也许更好理解�Q?br />

//创徏Type�c�d��的对象a
Type a;

//对a的对象内部数据成员赋�?/span>

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

�׃��b的复制构造函数的参数被定义�ؓ(f��)��g��递，那么首先�?x��)创��Z��个Type的��(f��)时变量，假设为temp1�Q�然后再传递给b的复制构造函�?br />

Type temp1( a )

�׃��temp1的复制构造函数的参数被定义�ؓ(f��)��g��递，那么首先�?x��)创��Z��个Type的��(f��)时变量，假设为temp2�Q�然后再传递给b的复制构造函�?br />

Type temp2( a )

�c�L��,�?x��)出现temp3,temp4,...直至无穷多！

所以复制构造函数的参数必须为引�?img src ="http://www.shnenglu.com/xiaowugui/aggbug/172397.html" width = "1" height = "1" />

��乌�?/a> 2012-04-23 00:21 发表评论

C语言获取文�g大小

Fri, 22 Oct 2010 03:22:00 GMT

今天去面试，面试官问了个C中如何获取文件大��，惛_��惻I��没有�q�个函数啊。那应该是用fseek��文件指针移动到文�g末尾�Q�然后通过文�g指针获取吧？但是什么函数呢�Q�没印象�Q�汗......
回来查了下，原来是ftell�Q��?zh��n)�剧啊�Q�以前没用过�Q�MSDN上ftell的功能如下：(x��)Gets the current position of a file pointer。写了段代码��试了下�Q�代码如下：(x��)

#include <stdio.h>

int main()
{
    long fileSize = 0;

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

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

��乌�?/a> 2010-10-22 11:22 发表评论

string中的+, =, +=

Sun, 23 Nov 2008 08:14:00 GMT

看一�D늮�单的代码�Q?br>

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

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

对不�Q�当然对的！参看basic_string.h中的源码�Q?br>

      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';    // = 也定义了双��的��gؓ(f��)字符的情�?nbsp;
    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;

�q�是源码�Q?br>

// 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;
    }

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

��乌�?/a> 2008-11-23 16:14 发表评论

两次CTRL+Z才能中止�E�序

Sun, 26 Oct 2008 08:34:00 GMT

#include <stdio.h>

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

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

��乌�?/a> 2008-10-26 16:34 发表评论

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

Mon, 08 Sep 2008 17:27:00 GMT

ChinaUnix上看到有人问了一个问�?�E�序代码如下:

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

   一个�h的评�?
   数组char str[]在内存中存储方式:str�?amp;str是同一个�?也就是说str本��n在内存中没有占用�I�间,str�?amp;str�?amp;str[0]的值是一��L(f��ng)��Q�只是直接给str[]的数�l�元素分配了�I�间。指针char *str在内存中的存储方式：(x��)首先�?x��)给str变量本��n分配�I�间�Q�也��是说str�?amp;str的��D��定是不一��L(f��ng)��Q?amp;str��是str的地址�Q�在指针初始化后才给指针char *str所指向的字�W�串明确的分配空��_(d��)��当然�q�个�I�间的首地址��是str的倹{��所以数�l�和指针�q�是有区别的�Q�只是编译器�Ҏ(gu��)��针的处理是按照处理数�l�的方式来处理的�?br>  �q�个评�h(hu��n)真的是那么正��吗?
   先分析代�?三个输出一�?是因�?取地址�q�算�W�只能用于内存中的对�?卛_��量和数组元素.它不能作用于表达�?帔R��或register�c�d��的变�?The C Programming Language P93).
   那么字符串常量的�q�回值是什么呢?是指针变量吗?不像!有�h�?怎么不像�?当你把一个字�W�串帔R��作�ؓ(f��)一个参��C��递给函数,其行为就像指针啊.那就��x��数组,��数�l�名传递给函数,它的行�ؓ(f��)也像指针�?可数�l�名�l�究不是指针,只不�q�作为函数参数时,光��化�ؓ(f��)了指�?是不是像数组,的确有那�U�味�?不信��q��看下面的��试代码:

#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;
}

   输出�l�果�?
   7
   4
   7
   既然�q�样的话,那么数组名是变量�q�是帔R��?数组名实质上是这个数�l�的首地址�Q�一旦系�l�开辟了�q�块内存�Q�那么这个内存的首地址��׃��能改变，所以，�Ҏ(gu��)��l�名的赋��D��定是不允许的。数�l�名�{�同于常量，但是�q�有没有数组名就是常量的说法。这��p��明了数组名绝不是变量,当然也不是数�l�元素了.因此�Ҏ(gu��)��l�名取地址,要么是未定义,要么是非法的.对字�W�串帔R��取地址,很多�~�译器都可以通过,只是警告一�?因此对于数组str[],str�?amp;str是同一个值的说法是不�?因�ؓ(f��)&str�q�个本��n不合法或未定义的.
   �q�有他说:所以数�l�和指针�q�是有区别的�Q�只是编译器�Ҏ(gu��)��针的处理是按照处理数�l�的方式来处理的。数�l�当然和指针有区别了.数组名不是变�?而指针是.�~�译器对指针的处理是按照处理数组的方式来处理的吗?那么��Z��么用指针�~�写的程序比数组的快?
   The C Programming Language P98:在计��数�l�元素a[i]的值时,C语言实际上先��其转换�?(a+i)的�Ş�?然后再进行求�?�q�就说明了编译器�Ҏ(gu��)��l�的处理是按照指针的方式来处理的.同时也说明了��Z��么用指针�~�写的程序比用数�l�编写的�?

��乌�?/a> 2008-09-09 01:27 发表评论

Sat, 06 Sep 2008 03:42:00 GMT

用C-Free(使用默认的mingw�~�译�?�~�译一个程序的时�?出现了一个古怪的现象.MS如果一个程序有命��o(h��)行参��C��命��o(h��)行参��C��含有*,则编译器��׃��(x��)��?替换为本目录下的所有文件名,而用VC++6.0则不�?x��)出��C��上的情况.

��试了一�?的确如此.�E�序代码如下:

/* 包含头文�?nbsp;*/
#include <stdio.h>

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

   用C-Free4.0(使用默认的mingw�~�译�?�~�译成expr.exe.然后��其攄��于一个文件夹�?此时文�g多w��含有两个文�g:expr.exe和expr.txt.从命令行执行: expr.exe *,�l�果昄��:
   expr.exe
   expr.exe
   expr.txt

   用VC++6.0�~�译成expr2.exe,然后��它�U�d��此文件夹�?执行同样的命�? expr.exe *,�l�果如下:
   expr2.exe
   *

   如果*不是作�ؓ(f��)一个单独的参数,而是作�ؓ(f��)一个参数的一部分,情况�?x��)怎样,执行命��o(h��):expr.exe 1*2,�l�果如下:
   expr.exe
   1*2
   因此,在��用C-Free(默认�~�译器mingw)�~�译含有*命��o(h��)行参数的�E�序,务必��心.

��乌�?/a> 2008-09-06 11:42 发表评论

Fri, 01 Aug 2008 08:40:00 GMT

int n = -2147483648;

        如此��单的一句代码，居然出现了警告？-2147483648�?2位int�c�d��可以存储的最��整型��|��Z��么会(x��)出项警告呢。在VC++6.0控制台程序下出现如下警告�Q�warning C4146: unary minus operator applied to unsigned type, result still unsigned。在C-Free中出玎ͼ�(x��)c:55: warning: decimal constant is so large that it is unsigned�?br>
        上网查了下，发现了原因：(x��)
        一元负�q�算�W�应用于无符��L(f��ng)��型，�l�果仍�ؓ(f��)无符��L(f��ng)��型。无�W�号�c�d��只能保存非负��|��所以一元负�Q�非�Q�应用于无符��L(f��ng)��型时通常无意义。操作数和结果都是非负的�?nbsp;
        实际上，当程序员试图表达最��整数�?2147483648 �Ӟ��发生此问题。该��g��能写�?2147483648�Q�因��辑ּ�处理分两个步骤：(x��)
        计算数字2147483648。因�?147483648 大于最大整数�?147483647�Q�所以其�c�d��不是int�Q�而是unsigned int�?nbsp;
        ��一元负应用于该��|��得到无符��L(f��ng)��果，该结果碰巧是 2147483648。无�W�号�c�d��的结果可能导致意外行为。如果在比较中��用该�l�果�Q�则可��用无�W�号比较�Q�而不能出现另一个操作数�?int 时。这解释了下面的�C�Z��E�序只输��Z��行的原因�?nbsp;
        预期的第二行为：(x��)1 is greater than the most negative int�Q�但未输出，因�ؓ(f��)((unsigned int)1) > 2147483648为假�?nbsp;

#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);
}

        输出�l�果�Q?br>

        上面的解释省略了一些细节，我来补充下。在if (i > -2147483648)中，�׃��i为int�c�d��Q��?2147483648为unsigned int�c�d��Q�所有i��׃��(x��)被提升�ؓ(f��)unsigned int�c�d��Q�这��是C语言的整型提升�?10提升为unsigned int�c�d��后，其��D��定会(x��)大于2147483648�Q�因此第一条语句会(x��)打印出来。当把正整数�Q�比如本实验中的1�Q�提升�ؓ(f��)unsigned int�c�d��Ӟ��其值是不变的，因此肯定�?147483648要小�Q�所有第二条语句不会(x��)打印�?br>
      那如何来解决�q�个可恶的警告呢。网上说�Q�可以通过�?Limits.h 使用INT_MIN(一个宏定义) 来避免C4146 警告。INI_MIN宏有如何的魔力，竟然能够消除�q�个警告呢。打开源文件一看，原来是这��P��(x��)

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

哦，原来�q�样。因此，我们又可以这栯��值最��负整数�Q?br>

int n = -2147483647 - 1;

��乌�?/a> 2008-08-01 16:40 发表评论

C/C++中的枚�D

Tue, 29 Jul 2008 07:35:00 GMT

读K&R的The C Programmingh Language 2nd�Q�遇��C��疑问�Q�书中说�Q?#8220;��管可以声明enum�c�d��的变量，但编译器不检查这�U�类型的变量中存储的值是否�ؓ(f��)该枚丄��有效倹{��不�q�，枚�D变量提供�q�种��(g��)查，因此枚�D�?define更具优势�?#8221;
枚�D变量提供�q�种��(g��)查，什么意思？枚�D变量�?x��)自己检�Q�当然不是，作者也许想说程序员自己可以写个�E�序��(g��)查付�l�枚丑֏�量的值是否�ؓ(f��)该枚丄��有效倹{�?br>

/* 包含头文�?nbsp;*/
#include <stdio.h>

/* 枚�D�c�d�� */
enum months{JAN = 1, FEB};

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

main()
{
    enum months a = 2;
    enum months b = 50;        /* C中不需要强制�{换�ؓ(f��)enum months�c�d�� */

    enum months c = JAN;

    enumeration(a);
    enumeration(b);

    return 0;
}

/* enumeration函数�Q�检��枚丑֏�量存储的值是否�ؓ(f��)该枚丄��有效�?nbsp;*/
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;
    }
}

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

�Ҏ(gu��)��C标准的规定，枚�D帔R��的类型�ؓ(f��)int�Q�枚丑֏�量的�c�d��应该与char、有�W�号或无�W�号整型兼容。因此，枚�D变量可以接受 char、有�W�号或无�W�号整型敎ͼ�而不限于仅从此枚丄��型所定义的枚丑ָ�量中取倹{��由于上�q�原因，在C語言中无法从語法上保证枚丑֏�量只能在定义的枚举成员中取��|��只能��q��序员自��n保证不��用除枚�D成员之外的倹{�?br>
关于這一点，很多介绍C语言的书上或者资料上的描�q�是不正��的�Q�应该加以注意�?br>
但是�Q�如果给枚�D变量赋枚举成员之外的��|��有的�~�译器可能会(x��)�Ҏ(gu��)��产生警告�Q�有的则不會。因��U�行��Z��q�反C标准的规定，�~�译器对此如何反应都是有道理的�?br>
然而对于C++来说�Q�编译器�?x��)禁止给枚�D变量赋予枚�D成员之外的倹{��这是因为C++是一�U�强�c�d��语言�Q�枚丄��型不�{�同�?int �{�其它类型。虽然枚丄��型可以隐式�{化�ؓ(f��) int �{�类型，但是 int �{�类型却不能自动转化为枚丄��型，除非使用强制�c�d��转化。因此，如果不��用强制类型�{化的话，�l�枚丑֏�量赋值则只能从枚举成员中选择。对于枚丄��型要避免使用强制�c�d��转换。原因如下：(x��)

The C++ Programming Language上说:
如果某个枚�D中所有枚丑ր�非�?枚�D的表�C��围�ؓ(f��)[0 : 2^k-1];其中2^K是��所有枚举成员位于此范围内的最��的2的幂;如果是负�?��是[-2^k : 2^k-1]�?因此对一个给定的整数��|��如果使用强制�c�d��转换�Q�而其值又不在枚�D的表�C��围以内，其行为是未定义的�?br>

// 包含头文�?nbsp;
#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�Q�但�l�果是未定义的，因�ؓ(f��)此枚丄��表示范围为：(x��)0�?

    return 0;
}

��乌�?/a> 2008-07-29 15:35 发表评论

Mon, 28 Jul 2008 11:44:00 GMT

什么是�q�算�W�的�l�合性？

当两个运��符的优先��一��L(f��ng)��时候，先算哪一个的问题�Q�这��是�l�合性�?br>
首先要明白的是：(x��)�l�合性对于两个或两个以上的优先��一��L(f��ng)��q�算�W�才有意义�?br>比如�Q?br>

m = x + y - z;

�׃��术�q�算�W�的�l�合性是从左臛_��Q�因此上式等价于�Q?br>

m = (x + y) - z;

再比如：(x��)

#include <stdio.h>

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

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

�{�案是：(x��)52
�׃��*�?+的结合性从双��左，因此*++ptr�{��h(hu��n)�?(++ptr)

在网上查询资料的时候发玎ͼ�(x��)很多人问条�g�q�算�W�的�l�合性的问题�?br>

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
----�?br>3<0是假�Q�所以k不�ؓ(f��)9�Q��l�计��下一步�?br>k = ((i==3)?10:8);
----�?br>我们知道�q�时候i�{�于4�Q�所以，((i==3)为假�?br>所以k不等�?0�Q�而是�{�于8�?br>k = ((i==3)?10:8);
----�?br>k = 8

有�h问，那条件运��符的结合性且不是从左臛_��了，�q�与书上写的从右臛_��不符�Q?br>其实上面�Ҏ(gu��)��牉|��不到什么结合性的问题�Q�只有一个运��符�?x��)牵涉到�l�合性吗。而条件运��符是C中规定计��顺序的四个�q�算�W�之一�Q�因此上面的计算��序是完全正��的�?br>

��乌�?/a> 2008-07-28 19:44 发表评论