收集的一些c++知识点与题目一

收集的知识点都是之前没有接触过或者不太明白的，题目自己都有做过，如果有错误请提出~

//可变参数的函数
#include <stdarg.h>  
int count_f(int num, ...);
int main()  
{ 
	int a = count_f(5,1,2,3,4);
	cout<<a<<endl;

	return 0;
}  
int count_f(int num, ...)
{
	int sum_value = 0;

	va_list args;
	va_start(args,num);
	while(num--)
	{
		sum_value += va_arg(args,int);
	}
	va_end(args);
	return sum_value;
}

c++的可变参数函数与Lua比较类似，都是用“...”表示可变参数，用arg存储参数。

//类成员函数的缺省参数
class A 
{
public:
	void func(int a = 0 );
};
void A::func(int a)
{
	cout<<a<<endl;
}

只能在声明的时候给予缺省值，定义的时候不需要

//利用函数分配内存
//1利用指针
void mallocMemory1(char* p, int num)  
{  
    p=new char[num];//分配空间  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  
    char* test=NULL;  
    mallocMemory1(test,100);  
    strcpy_s(test,strlen(test),"HelloJacky");//赋值  
    return 0;  
}  
//2利用返回值传递动态内存
char* mallocMemory2(int num)  
{  
    char* p=new char[num];//分配空间  
    return p;//返回指针  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  
    char* test=NULL;  
    test=mallocMemory2(100);//给test赋值  
    strcpy(test,"HelloJacky");//赋值  
    return 0;  
}  
//3利用指向指针的指针
void mallocMemory3(char** p, int num)  
{  
    *p=new char[num];  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  
    char* test=NULL;  
    mallocMemory3(&test,100);//传入指针的地址  
    strcpy(test,"HelloJacky");//赋值  
    return 0;  
}

1.错误，会造成内存泄露，23都正确

//程序结束继续调用函数
int func(){cout<<"still"<<endl;return 0;}//必须返回int，且无参数
int main()
{
	cout<<"begin"<<endl;
	_onexit(func);
	cout<<"end"<<endl;
	return 0;
}

//计算字符串长度
const char *ptr = "what a f***!";
int main()
{
	int num = 0;
	const char *copy = ptr;

	while(*copy)
	{
		++num;
		cout<<"---roll--"<<endl;
		cout<<*copy<<endl;
		cout<<copy<<endl;
		cout<<num<<endl;
		*copy++;
	}

	cout<<"ptr:"<<ptr<<"has "<<num<<"character ";

	return 0;
}

//指向指针的引用
int main()
{
	int a=1,b=2;
	int *tmp = &a;
	int *&p = tmp;
	p=&b;
	*p = 5;

	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
	cout<<"*tmp="<<*tmp<<endl;
	return 0;
}

输出为：

a=1

b=5

*tmp=5

a,b的值好理解，至于为什么*tmp是5需要仔细看看，因为从始至终只有*tmp = &a，它应该指向a的地址对吧？答案肯定是不对的。

从代码*&p = tmp可以看出p是一个“ int* ”型的引用，也就是指向指针的引用，引用的作用我们都知道，它仅仅是一个变量的别名，那这里p就是“ *tmp ”的别名了，所以p = &b这句话也可以看成*tmp = &b，就是在这里，*tmp指向了b。那*p=5到底干了什么也就知道了。

//已知String类定义如下：
//class String
//{
//public:
//String(const char *str = NULL); // 通用构造函数
//String(const String &another); // 拷贝构造函数
//~ String(); // 析构函数
//String & operater =(const String &rhs); // 赋值函数
//private:
//char *m_data; // 用于保存字符串
//};
//尝试写出类的成员函数实现。
class mString
{
public:
	mString(const char *str = NULL);
	mString(const mString &another);
	~mString();
	mString & operator = (const mString &rhs);
	const char* getString();
private:
	char *m_data;
};

mString::mString(const char *str)
{
	cout<<"调用str构造函数"<<endl;
	if( str == NULL )
	{
		m_data = new char[1];
		m_data[0] = '\0';
		return;
	}
	m_data  = new char[strlen(str)+1];
	strcpy_s(m_data,strlen(str)+1,str);
}
mString::mString(const mString &another)
{
	cout<<"调用mString构造函数"<<endl;
	m_data = new char[strlen(another.m_data)+1];
	strcpy_s(m_data,strlen(another.m_data)+1,another.m_data);
}
mString& mString::operator =(const mString &rhs)
{
	cout<<"调用=操作符重载函数"<<endl;
	if( this ==	&rhs )
	{
		return *this;
	}
	if( m_data != NULL )
	{
		delete[] m_data;
	}
	m_data = new char[strlen(rhs.m_data)+1];
	strcpy_s(m_data,strlen(rhs.m_data)+1,rhs.m_data);
	return *this;

}
mString::~mString()
{
	cout<<"调用析构函数"<<endl;
	if( m_data != NULL )
	{
		delete[] m_data;
	}
}
const char* mString::getString()
{
	return m_data;
}

int main()
{
	mString me("nihao");
	cout<<me.getString()<<endl;
	mString he=me;
	cout<<he.getString()<<endl;
	return 0;
}

//已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)
//其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，
//请编写函数 strcpy。
/*
char *mstrcpy(char *strDest, const char *strSrc)
{
	if ( strDest == NULL || strSrc == NULL)
		return NULL ;
	if ( strDest == strSrc)
		return strDest ;
	char *tempptr = strDest ;
	//while( (*strDest++ = *strSrc++) != '\0');
	while (1)
	{
		*strDest++ = *strSrc++;
		if(*strSrc == '\0')
		{
			*strDest++ = '\0';
			break;
		}
	}
	return tempptr ;
}

int main()
{
	char a[5] = {"qwe"};
	char b[5] = {"abc"};
	mstrcpy(a,b);
	cout<<a<<endl;
	return 0;
}

我在网上查了些资料，好像很多底层代码的strcpy都是没有判断的，也就是说遇到错误马上crash，关于这点，也有些解释：

strcpy作为底层API是会被大量调用的，如果每次都判断是否合法就需要消耗很大一部分系统资源，还不如将判断交给调用者自己，遇到错直接终止也容易查到错误。

我觉得他们说的不无道理，就像游戏优化不能过度一样，我们应该视情况而定。

但是作为一个笔试题，出题者肯定是想考察我们的逻辑能力吧，所以这么写比较好。

//不用中间变量交换两个值
void fun1(int &a, int &b)
{
	a = a + b;
	b = a - b;
	a = a - b;
}d fun3(int &a, int &b)
{
	a ^= b;
	b ^= a;
	a ^= b;
}
int main()
{
	int a = 1;
	int b = 2;
	fun1(a,b);
	cout<<a<<"--"<<b<<endl;
	fun3(a,b);
	cout<<a<<"--"<<b<<endl;
	return 0;
}

fun1很好理解，fun3到是没有接触过，^是按位异或运算。道理是差不多的。比如a=1010，b=1001；

a ^= b     ==>     a = a^b     ==>     a = 0011

b ^= a     ==>     b = b^a     ==>     b = 1010

a ^= b     ==>     a = a^b     ==>     a = 1001

//试编写函数判断计算机的字节存储顺序是开序(little endian)还是降序(bigendian)
bool isBigendian()
{
	unsigned short a = 0x1122;
	unsigned char *b = (unsigned char *)&a;
	return (*b == 0x11);
}
int main()
{
	if(isBigendian())
	{
		cout<<"is bigendian"<<endl;
	}
	else
	{
		cout<<"is little endian"<<endl;
	}
	return 0;
}

这个是涨知识了。

//写一个输入的整数,倒着输出整数的函数,要求用递归方法 ;
//仅仅是倒着输出
#include <math.h>
void fun(int a)
{
	 cout<<a%10<<endl;
	a /= 10;
	if( a <=0 )return;
	fun( a );
}
//将整数转换成倒着的
int getn(int a)//获取整数有几位
{
	int n = 0;
	while(1)
	{
		if((a = a/10) <= 0)
		{
			break;
		}
		n++;
	}
	return n;
}
int change(int a)//转换
{
	if(a/10 < 1)
	{
		return a;
	}
	int af_num;//变换后的数
	int n_num = pow(10,getn(a));//倍数
	int af_a = a%10;//要变换位置的数值
	af_num = af_a*n_num + change(a/10);
	
	return af_num;

}
int main()
{
	int a;
	cin>>a;
	int af_a = change(a);
	cout<<"after change,a="<<af_a<<endl;
}

一开始看到题目写的是change函数，后来看到答案才发现自己理解错了，审题很重要。