c/c++中需要注意的小知识点

1. 函数的参数传递方式

• 按值传递(跟Java一样。因为Java中没有指针)
• 按引用传递

在实例中，交换函数最能体现函数的参数传递方式。

#include<iostream>

using namespace std;

void swap(char *a, char *b);
void swap1(char **a, char **b);
void swap2(char* &a, char* &b);

int main()
{
	char *a = "first", *b = "second";
	cout << a << " " << b << endl;
	
	swap(a,b);
	cout << a << " " << b << endl;
	
	swap1(&a,&b);
	cout << a << " " << b << endl;
	
	swap2(a,b);
	cout << a << " " << b << endl;

	return 0;
}

void swap(char *a, char *b)
{
	char *temp = a;
	a = b;
	b = temp;
}

void swap1(char **a, char **b)
{
	char *temp = *a;
	*a = *b;
	*b = temp;
}

void swap2(char* &a, char* &b)
{
	char* temp = a;
	a = b;
	b = temp;
}

结果:
a=first,b=second
a=first,b=second
a=second,b=first
x=1,y=2
x=2,y=1

2.在C＋＋中的多个结果输出的顺序
按照从右向左计算，从左向右输出。

#include<iostream>

using namespace std;

int main(){
	int n = 10;	
	cout << n << "," << n++ << endl;
}

结果： 11，10
3。 C＋＋中的变量作用域
同一变量名，由于他们的作用域不同，表示的对象也不同。全局变量进入局部变量的作用域时，全局变量是不可见的，因而不能引用。不过可以使用作用域区分符"::"来访问。指示所要引用的变量是全局变量。

#include<iostream>

using namespace std;
int a = 10;
int main(){
	int a = 20;
	cout << "a=\t" << a << endl;
	cout << "::a=\t" << ::a << endl;
}

结果:
a=      20
::a=    10

4。函数变量的缺省值

#include<iostream>

using namespace std;

int sum(int a=1, int b=1);
int sum1(int , int =22);
int main(){
	int a=10,b=20;
	cout << "sum=" << sum() << endl;
	cout << "sum=" << sum(a) << endl;
	cout << "sum=" << sum(a,b) << endl;

	cout << "sum1" << sum1(a) << endl;
}

int sum(int a, int b){
	return a + b;
}

int sum1(int a, int b){
	return a + b;
}

结果:
sum=2
sum=11
sum=30
sum1=32

5。运算符重载
运算符重载相当于写一个重载的函数，这样理解的话，写起来会方便很多。运算符重载分为成员函数和友元函数重载运算符。
(1) 成员函数

#include<iostream>

using namespace std;

class Num{
	private:
		int num;
	public:
		Num(int num = 0){this->num = num;}
		int getNum(){return this->num;}
		void setNum(int num){this->num = num;}
		void printNum(){cout << this->num << endl;}
		Num operator+(Num num_obj);
};

Num Num::operator+(Num num_obj){
	Num temp;
	int result = this->getNum() + num_obj.getNum();
	temp.setNum(result);
	return temp;
}

int main(){
	Num num1(1),num2(2),num3;
	num3 = num1 + num2;
	num3.printNum();
}

结果是:3
(2) 友元函数

#include<iostream>

using namespace std;

class Num{
	private:
		int num;
	public:
		Num(int num = 0){this->num = num;}
		int getNum(){return this->num;}
		void setNum(int num){this->num = num;}
		void printNum(){cout << this->num << endl;}
		friend Num operator+(int num, Num num_obj);
};

Num operator+(int num, Num num_obj){
	Num temp;
	int result = num + num_obj.getNum();
	temp.setNum(result);
	return temp;
}

int main(){
	Num num1(1),num3;
	int _num = 2;
	num3 = 2 + num1;
	num3.printNum();
}

结果:3

6. C++中的多重继承
跟Java不同，C++支持多重继承，这也给C++带来了需要解决的问题－－二义性。因此出现了virtual关键字，出现了虚基类来消除二义性。

(1) 问题

#include<iostream>

using namespace std;

class Base{
	public:
		void print(){cout << "in Base class" << endl;}
};

class Base1 : public Base{};
class Base2 : public Base{};

class Base3 : public Base1, public Base2{};

int main(){
	Base3 base3;
	base3.print();
}

编译结果:
[root@NetFPGA11 c]# g++ virtual.cc -o virtual
virtual.cc: In function ‘int main()’:
virtual.cc:17: error: request for member ‘print’ is ambiguous
virtual.cc:7: error: candidates are: void Base::print()
virtual.cc:7: error:                 void Base::print()
(2)改成如下的虚基类，便解决了二义性问题。

#include<iostream>

using namespace std;

class Base{
	public:
		void print(){cout << "in Base class" << endl;}
};

class Base1 : virtual public Base{};
class Base2 : virtual public Base{};

class Base3 : public Base1, public Base2{};

int main(){
	Base3 base3;
	base3.print();
}

结果:in Base class

7.C++中的多态性
在C++中，多态性是由虚函数或者纯虚函数(包含纯虚函数的类叫做抽象类)来实现的。不同于Java本身就是多态的。多态性的表现形式为父类可以指向子类，这样如果不同的子类对父类同一方法进行了重写，那么会调用相应子类的方法。

8. C++中的友元函数或者友元类
(])友元函数。

#include<iostream>

using namespace std;

class A{
	private:
		int a;
	public:
		void setA(int x){a = x;}
		int getA(){return a;}
		friend void square(A &a_obj);//声明友元函数
};

void square(A &a_obj){//定义时不需要使用A::来指出属于哪个类，因为友元函数不属于任何一个类，不是类的成员函数
	cout << "square of " << a_obj.a << " is " << a_obj.a * a_obj.a << endl;
}

int main(){
	A a_obj;
	a_obj.setA(10);
	square(a_obj);
	cout << "A.a=" << a_obj.getA() << endl;
}

结果:
square of 10 is 100
A.a=10

(])友元成员函数。

#include<iostream>

using namespace std;

class x2;
class x1{
	private:
		char flag;
	public:
		void setFlag(char _flag){flag = _flag;}
		void printX2(x2 x);
};

class x2{
	private:
		char flag;
	public:
		void setFlag(char _flag){flag = _flag;}
		friend void x1::printX2(x2 x);
};

void x1::printX2(x2 x){
	cout << "x2 flag is " <<  x.flag << endl;
}

int main(){
	x1 _x1;
	_x1.setFlag('1');
	x2 _x2;
	_x2.setFlag('2');
	_x1.printX2(_x2);
}

结果:
x2 flag is 2
(3)友元类。

#include<iostream>

using namespace std;

class x1{
	friend class x2;// x2成为了x1的友元类，这样x2便可以访问x1的私有成员变量
	private:
		char flag;
	public:
		void setFlag(char _flag){flag = _flag;}
		void printFlag(){cout << "x1 flag is " << flag << endl;};
};

class x2{
	private:
		char flag;
	public:
		void setFlag(char _flag){flag = _flag;}
		void printFlag(){cout << "x2 flag is " << flag << endl;}
		void printFlag_x1(x1 _x1){cout << "x1 flag is " << _x1.flag << endl;}
};

int main(){
	x1 _x1;
	_x1.setFlag('1');
	x2 _x2;
	_x2.setFlag('2');

	_x2.printFlag();
	_x2.printFlag_x1(_x1);
}

结果：
x2 flag is 2
x1 flag is 1

9.C/C++中的原始数据类型

#include<stdio.h>

int main(){
	printf("char \tsize is: %d\n",sizeof(char));
	printf("short \tsize is: %d\n",sizeof(short));
	printf("int \tsize is: %d\n",sizeof(int));
	printf("long \tsize is: %d\n",sizeof(long));
	printf("float \tsize is: %d\n",sizeof(float));
	printf("double \tsize is: %d\n",sizeof(double));
}

结果：
char    size is: 1
short   size is: 2
int     size is: 4
long    size is: 4
float   size is: 4
double  size is: 8


10. C中的格式化输入输出
在其中经常遇到的标志符有:

d	f	e	c	s	o	x
十进制整数	十进制浮点数	指数形式的浮点数	字符	字符串	十六进制这个念书	八进制整数

在%和标志符之间可以使用数字来规范化输入输出:如
%9.2f //长度为9，小数位数为2的浮点数输出，其中小数点一位，整数位6位。如果不够的话，会以空格补齐使得右对齐(默认的对齐方式)，如果实际的位数超过了输出的要求，那么会保留原来的数据内容。若想在左边补齐的方式是以0来填充，若要改变默认的对齐方式，可以用"-"来实现。但对于字符串来说，标志符前面的数字代表不同的意思。则在最前面补0。如下:

#include<stdio.h>

int main(){
	float f = 3.12;
	printf("%6.1f",f);//宽度为6，包括整数、小数点和小数在内共有3位，故左边会有3个空格补齐位
	printf("%4.1f\n",f);//宽度为4，左边有1个空格补齐位

	printf("%-6.1f",f);//左对齐
	printf("%-4.1f\n",f);

	printf("%2.1f",f);//宽度为2，而数据输出为3位，故保留了原来的数据，数据宽度成为了3。
	printf("%3.1f\n",f);

	printf("%06.1f",f);//用0补齐
	printf("%04.1f\n",f);

	char *s = "Hello World";
	printf("%6.9s\n",s);//输出的字符串长度为6到9位
	printf("%15.20s\n",s);
}

结果:
   3.1 3.1
3.1   3.1
3.13.1
0003.103.1
Hello Wor
    Hello World

#include <iostream>

using namespace std;

int main()
{
	//const 和 int 是可以交换位置，比如 const int* 和 int const* 是一样的，但不能和int*交换，也就是和int* const 不一样。 只要const能交换到最开始，这说明这个是内容不可变，否则是地址不可变

	int one = 1, two = 2, three = 3;
	const int* pOne = &one;// 指针指向地址的内容不可改变
	int* const pTwo = &two;// 指针指向的地址不可改变

	cout << *pOne << " " << *pTwo << endl;

// 	//*pOne = three;// error
// 	pOne = &three;
// 	cout << *pOne << " " << *pTwo << endl;


	//pTwo = &three; //error
	*pTwo = three;
	cout << *pOne << " " << *pTwo << endl;

	return 0;
}

11.四种生命周期的对象：
1） 全局对象，程序一开始，其构造函数就先被执行（比程序进入点更早），程序即将结束前其析构函数被调用
2） 局部对象，当对象诞生时其构造函数被执行，当程序流程将离开该对象的存活范围的时候其析构函数被调用
3） 静态对象当对象诞生时其构造函数被执行，当程序即将结束时其析构函数被调用，但比全局对象要早调用析构函数
4） 以new 方式产生的局部对象对象诞生时其构造函数被执行，当对象被delete掉的时候 析构函数被调用


12.面向对象语言的三个特点：
封装、继承、多态（c++中虚函数是来实现多态的关键）