积累的c/c++ 一些小程序

#include "stdafx.h"
#include <memory.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <conio.h>
#include <iostream>
#include <fstream>

using namespace std;
/*
bool getstr( char **ostrbuf )//若用char* 在Main中不能传递ostrbuf
{
    char szDataBuf[100];
    memset( szDataBuf, 0x01, sizeof( szDataBuf ) );

 *ostrbuf = (char *)malloc( sizeof(szDataBuf)+1 );
 strcpy( *ostrbuf, szDataBuf );

 return true;
}
int main(int argc, char* argv[])
{
 char *ostrbuf = "dd";
 getstr(&ostrbuf);
 printf("%s",ostrbuf);

 return true;
}
*/
/*
#pragma pack(4) //VC  中可以通过pack指令修改默认对齐方式
//默认为4，若改为1则sizeof(TT)为11
class TT
{
 static int v6;//静态数据成员在分配在全局区
 void fun();//普通函数在编译期间就已分配好地址,因此在sizeof中无体现
 virtual void vfun1();
 virtual void vfun2();//虚函数表指针占4个字节
 char v1;
 char v2;
 char v5;//4
 int v3;//4
 int  v4;//4
 double d1;//8
 char *p;//4
 char c[10];//12
};

int main( void )
{
 cout << sizeof(TT);//40

  
 return 0;
}
*/
/*
#define STRCPY(a, b)    strcpy(a ## _p, #b) //相当于strcpy(a_p,"b");
int main()
{
    char var1_p[20];
    char var2_p[30];
    strcpy(var1_p, "aaaa");
    strcpy(var2_p, "bbbb");
    STRCPY(var1, var2); //strcpy(var1_p,"var2");
    STRCPY(var2, var1); //strcpy(var2_p,"var1");
    printf("var1 = %s/n", var1_p);
    printf("var2 = %s/n", var2_p);
    return 0;
}
*/
/*
int main()
{
 int array[4] = {1,2,3,4};
 int result = 0;
 int index = 0;
 
 result = array[index++] - array[index++]; //编译器执行顺序为先进行两次++运算，再做减法
 //像++ -- 这样有副作用的运算最好分行写
 cout << result << endl;

 return 0;
}
*/
/*
1. 以下三条输出语句分别输出什么？[C易]
char str1[]       = "abc";
char str2[]       = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char* str5  = "abc";
const char* str6  = "abc";
cout << boolalpha << ( str1==str2 ) << endl; // 输出什么？
cout << boolalpha << ( str3==str4 ) << endl; // 输出什么？
cout << boolalpha << ( str5==str6 ) << endl; // 输出什么？

答：分别输出false,false,true。str1和str2都是字符数组，每个都有其自己的存储区，它们的值则是各存储区首地址，不等；str3和str4同上，只是按const语义，它们所指向的数据区不能修改。str5和str6并非数组而是字符指针，并不分配存储区，其后的“abc”以常量形式存于静态数据区，而它们自己仅是指向该区首地址的指针，相等。

12. 以下代码中的两个sizeof用法有问题吗？[C易]
void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
    for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )
        if( 'a'<=str[i] && str[i]<='z' )
            str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;

答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为6，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。

13. 非C++内建型别 A 和 B，在哪几种情况下B能隐式转化为A？[C++中等]
答：
a. class B : public A { ……} // B公有继承自A，可以是间接继承的
b. class B { operator A( ); } // B实现了隐式转化为A的转化
c. class A { A( const B& ); } // A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数
d. A& operator= ( const A& ); // 赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个

4. 以下代码有什么问题？[C++易]
struct Test
{
    Test( int ) {}
    Test() {}
    void fun() {}
};
void main( void )
{
    Test a(1);
    a.fun();
    Test b();
    b.fun();
}

答：变量b定义出错。按默认构造函数定义对象，不需要加括号。

5. 以下代码有什么问题？[C++易]
cout << (true?1:"1") << endl;
答：三元表达式“？:”问号后面的两个操作数必须为同一类型。

8. 以下代码能够编译通过吗，为什么？[C++易]
unsigned int const size1 = 2;
char str1[ size1 ];
unsigned int temp = 0;
cin >> temp;
unsigned int const size2 = temp;
char str2[ size2 ];
答：str2定义出错，size2非编译器期间常量，而数组定义要求长度必须为编译期常量。

2. 以下反向遍历array数组的方法有什么错误？[STL易]
vector array;
array.push_back( 1 );
array.push_back( 2 );
array.push_back( 3 );
for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍历array数组
{
    cout << array[i] << endl;
}

答：首先数组定义有误，应加上类型参数：vector<int> array。其次vector::size_type被定义为unsigned int，即无符号数，这样做为循环变量的i为0时再减1就会变成最大的整数，导致循环失去控制。

9. 以下代码中的输出语句输出0吗，为什么？[C++易]
struct CLS
{
    int m_i;
    CLS( int i ) : m_i(i) {}
    CLS()
    {
        CLS(0);
    }
};
CLS obj;
cout << obj.m_i << endl;

答：不能。在默认构造函数内部再调用带参的构造函数属用户行为而非编译器行为，亦即仅执行函数调用，而不会执行其后的初始化表达式。只有在生成对象时，初始化表达式才会随相应的构造函数一起调用。

10. C++中的空类，默认产生哪些类成员函数？[C++易]
答：
class Empty
{
public:
    Empty();                          // 缺省构造函数
    Empty( const Empty& );            // 拷贝构造函数
    ~Empty();                         // 析构函数
    Empty& operator=( const Empty& ); // 赋值运算符
    Empty* operator&();               // 取址运算符
    const Empty* operator&() const;   // 取址运算符 const
};

 
3. 以下两条输出语句分别输出什么？[C++难]
float a = 1.0f;
cout << (int)a << endl;
cout << (int&)a << endl;
cout << boolalpha << ( (int)a == (int&)a ) << endl; // 输出什么？
float b = 0.0f;
cout << (int)b << endl;
cout << (int&)b << endl;
cout << boolalpha << ( (int)b == (int&)b ) << endl; // 输出什么？

答：分别输出false和true。注意转换的应用。(int)a实际上是以浮点数a为参数构造了一个整型数，该整数的值是1，(int&)a则是告诉编译器将a当作整数看（并没有做任何实质上的转换）。因为1以整数形式存放和以浮点形式存放其内存数据是不一样的，因此两者不等。对b的两种转换意义同上，但是0的整数形式和浮点形式其内存数据是一样的，因此在这种特殊情形下，两者相等（仅仅在数值意义上）。
注意，程序的输出会显示(int&)a=1065353216，这个值是怎么来的呢？前面已经说了，1以浮点数形式存放在内存中，按ieee754规定，其内容为0x0000803F（已考虑字节反序）。这也就是a这个变量所占据的内存单元的值。当(int&)a出现时，它相当于告诉它的上下文：“把这块地址当做整数看待！不要管它原来是什么。”这样，内容0x0000803F按整数解释，其值正好就是1065353216（十进制数）。
通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说，而(int&)的作用则仅仅是表达了一个类型信息，意义在于为cout<<及==选择正确的重载版本。

6. 以下代码有什么问题？[STL易]
typedef vector IntArray;
IntArray array;
array.push_back( 1 );
array.push_back( 2 );
array.push_back( 2 );
array.push_back( 3 );
// 删除array数组中所有的2
for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )
{
    if( 2 == *itor ) array.erase( itor );
}

答：同样有缺少类型参数的问题。另外，每次调用“array.erase( itor );”，被删除元素之后的内容会自动往前移，导致迭代漏项，应在删除一项后使itor--，使之从已经前移的下一个元素起继续遍历。
 
11. 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]
答：
void* mymemcpy( void *dest, const void *src, size_t count )
{
    char* pdest = static_cast<char*>( dest );
    const char* psrc = static_cast<const char*>( src );
    if( pdest>psrc && pdest<psrc+cout ) 能考虑到这种情况就行了
    {
        for( size_t i=count-1; i!=-1; --i )
                pdest[i] = psrc[i];
    }
    else
    {
        for( size_t i=0; i<count; ++i )
            pdest[i] = psrc[i];
    }
    return dest;
}
*/
/*
int main(void)
{
 int i = 0;
 i++++;//error
 ++++i;//OK
 return 0;
}
*/
/*
int main(void)
{
 void test();
 test();
 test();
 return 0;
}
void test()
{
 static int i = 2; //静态局部变量只被初始化一次
 i++;
 cout << i << endl;
}
*/
/*
int main(void)
{
 char first[100];
 char last[100];
 char full_name[100];
 
 printf("First:");
 fgets(first,sizeof(first),stdin); //"fgets" retains the newline character
         //while "gets" replace the newline character with NULL

 printf("Last:");
 fgets(last,sizeof(last),stdin);

 strcpy(full_name,first);
 strcat(full_name,"");
 strcat(full_name,last);

 printf("hello! %s/n",full_name);
 printf("hello");
 return 0;
}
*/
/*
void main( void )
{
   int integer;
   char string[81];

   // Read each word as a string.
   printf( "Enter a sentence of four words with scanf: " );
   for( integer = 0; integer < 4; integer++ )
   {
      scanf( "%s", string );
      printf( "%s/n", string );
   }

   // You must flush the input buffer before using gets.
   fflush( stdin );
   printf( "Enter the same sentence with gets: " );
   gets( string );
   printf( "%s/n", string );
}
*/
/*
class var_array
{
sprivate:
 int *data;
 int size;
public:
 var_array(const int _size):size(_size)
 {
  data = new int[size];
  memset(data,'/0',sizeof(int)*size);
 }

 ~var_array(void)
 {
  delete []data;
 }

 int &operator [](const unsigned index)
 {
  return (data[index]);
 }
 var_array(const var_array& old)
 {
  *this = old;
 }
 var_array &operator = (const var_array &old)
 {
  size = old.size;
  data = old.data;
  
  return (*this);
 }
};

static void store_it( var_array test_array)//调用拷贝构造函数，再次生成var_array
//对象，导致调用两次析构函数，释放同一块堆.
// 改为(var_array &test_array)
{
 test_array[1] = 1; 
 test_array[3] = 3;
}
int main()
{
 var_array test_array(30);

 store_it(test_array);
 return 0;
}
*/
/*
const int STACK_MAX = 100;
class stack
{
public:
 int count;
 int *data;
 stack(void):count(0)
 {
  data = new int[STACK_MAX];
 }
};
class safe_stack:public stack
{
public:
 const int max;
 safe_stack(void):max(STACK_MAX)
 {
 }
};
void stack_count(stack *stack_array, const int n_stacks)//派生对象数组和基类数组不一样
//sizeof(stack) 和 sizeof(safe_stack) 不同，用基类指针指向派生数组，内存布局出错。
{
 int i;
 for(i=0;i<n_stacks;++i)
 {
  cout << i<< "   " << stack_array[i].count << endl;
 }

}
static safe_stack stack_array[5];
int main(void)
{
 stack_count(stack_array,5);
 return 0;
}
*/
/*
class info
{
private:
 const int start;
 const int end;
 char data[30];

public:
 info(void):start(100),end(200)
 {
 }
 void set_data(const char what[])
 {
  strcpy(data,what);
 }
 void out_start_end()
 {
  cout << start << endl;
  cout << end << endl;
 }
};
info *new_info(void)
{
 info *result;
 result = (info *)malloc(sizeof(info));//malloc不调用构造函数
 memset(result,'/0',sizeof(*result));//将类对象清零

 return result;
}
int main()
{
 info *result = new_info();
 result->set_data("Data");
 result->out_start_end();

 return 0;
}
*/
/*
int main(void)
{
 unsigned char cur_char;

 std::ofstream out_file;
//以16进制查看test.out 文件，发现0a(回车)后面是0d(换行),一共129个字符输出
 out_file.open("c://test.out",std::ios::out);
 for(cur_char=0;cur_char<128;++cur_char)
  out_file << cur_char;
 return 0;
}
*/
/*
#define Diff(a, temp)/
 temp = 0x80000000; /
 a = (((a | temp) >> 1) & temp);/
 if (a == 0)/
  cout<<"unsigned int"<<endl;/
 else /
  cout<<"int"<<endl;
int main()//判断一个数字是int 还是 unsigned int
{
 int a;
 unsigned b;
 int temp;
 Diff(b, temp);
 Diff(a, temp);
 return 0;
}
*/
/*
char* GetType(unsigned int i)
{
 return "unsigned int";
}
char* GetType(int i)
{
 return "int";
}
main()//重载GetType()
{
 int iData;
 unsigned uData;
 cout << GetType(uData) << endl;
 cout << GetType(iData) << endl;
 return 0;
}
*/