C++类和对象

初始化列表：
在C++的类中给成员变量赋值，可以在构造函数中赋值：

#include<iostream>
using namespace std;

class A
{

public:
	A(int a, int b, int c)
	
	{
		_a = a;
		_b = b;
		_c = c;
	}

	void print()
	{
		cout << _a << _b << _c << endl;
	}
private:
	int _a;
	int _b;
	int _c;
};
int main()
{
	A a(1,2,3);
	a.print();
	return 0;
}

但是构造函数可以多次赋值：

class A
{

public:
	A(int a, int b, int c)
	
	{
		_a = a;
		_b = b;
		_c = c;
		_a = a;
	}

	void print()
	{
		cout << _a << _b << _c << endl;
	}
private:
	int _a;
	int _b;
	int _c;
};

而初始化列表只能初始化一次：
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括 号中的初始值或表达式。

class A
{

public:
	A(int a, int b, int c)
		:_a(a)
		,_b(b)
		,_c(c)
	{
	}

	void print()
	{
		cout << _a << _b << _c << endl;
	}
private:
	int _a;
	int _b;
	int _c;
};

初始化列表也可以跟赋值混用：

class A
{

public:
	A(int a, int b, int c)
		:_a(a)
		,_b(b)
	{
		_c = c;
	}

	void print()
	{
		cout << _a << _b << _c << endl;
	}
private:
	int _a;
	int _b;
	int _c;
};
int main()
{
	A a(1,2,3);
	a.print();
	return 0;
}

或者初始化后再次赋值：
class A
{

public:
A(int a, int b, int c)
:_a(a)
,_b(b)
{
_c = c;
_a = 3;
}

void print()
{
	cout << _a << _b << _c << endl;
}

private:
int _a;
int _b;
int _c;
};
int main()
{
A a(1,2,3);
a.print();
return 0;
}

但是成员变量不能多次初始化，const和引用变量要在定义的时候初始化：

public:
	A(int a, int b, int c)
		:_a(a)
		,_b(b)
		,_i(1)
	{
		_c = c;
		_a = 3;
	}

	void print()
	{
		cout << _a << _b << _c << endl;
	}
private:
	int _a;
	int _b;
	int _c;

	const int _i = 1;
	const int& _p = _i;
};

没有默认构造函数的类：

class A
{

public:

	//默认构造函数有三种：
	//1,不显视定义编译器自动生成的
	//2，全缺省
	//3,不带参数

	//而下面这种，不属于上面三种，所以不是默认构造函数
	//对于没有默认构造函数的类，必须在定义的时候初始化
	A(int a)
		:_a(a)
	{
		cout << a << endl;
	}

private:
	int _a;
};


class B
{
public:
	B(int a = 1, int b = 2, int c = 3)
		:_a(a)
		,_b(b)
		,_c(c)
		,b(10)//没有默认构造函数的类，必须在初始化列表进行初始化
	{
		cout << _a << _b << _c << endl;
	}
private:
	int _a;
	int _b;
	int _c;

	A b;
};

static静态：
现在有一个这样的题目：
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C)

非常的为难人。。。。。。

如果要满足上面的条件，完成1+2+3+…+n，首先要有一个一直累加的变量，其次要有一个变量从1 ++ 到n，如果不能使用上面的关键字，可以用一个很巧妙的方法来实现：

class Sum
{
    public:
    	//_i _j由于是静态变量
    	//所以只会初始化一次
        Sum()
        {
            _j+=_i;
            _i++;
        }

      int rt()
        {
            return _j;
        }

    private:
        //定义两个静态变量
        static int _i ;//i用来从1开始不断自增
        static int _j ;//j用来保存每次+i的结果

};

//初始化静态变量
int Sum::_i = 1;
int Sum::_j = 0;

class Solution {
public:
    int Sum_Solution(int n) {
    //创建一个n大小的数组
    //每个数组在创建的时候都会调用默认构造函数
    //每次调用默认构造函数，_j都会加上_i
    //_i都自增
    //调用10次，i最后会变成10
    //_j也会从1加到10
        Sum arr[n];
        return arr[0].rt();
    }
};

题目链接

注意：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

友元：
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以
友元不宜多用。
友元分为：友元函数和友元类

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class A
{
public:
	//友元函数声明：
	friend void Print(A a);

	A()
		:_a(10)
		,_b(20)
	{
	}
private:
	int _a;
	int _b;

};

//友元函数
void Print(A a)
{
	cout << a._a <<a._b << endl;
}



int main()
{

	A a;
	//直接访问a中的成员变量是不行的，因为类在设计的时候已经使用private封装了
	//这里使用友元函数可以直接访问
	Print(a);
	
	return 0;
}

说明:
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

友元类：

class A
{
public:
	friend class B; // 声明A类为B类的友元类，则在B类中就直接访问A类中的私有成员变量
	A()
		:_a(30)
		,_b(40)
	{
	}
private:
	int _a;
	int _b;

};

class B
{
public:
	B()
		:_a(10)
		, _b(20)
	{
		cout << _A._a << _A._b << endl;
	}
private:
	int _a;
	int _b;

	//在B类中创建一个A类，可以直接访问A类中的私有成员变量
	A _A;

};





int main()
{

	B b;
	
	
	return 0;
}

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

友元关系是单向的，不具有交换性。

比如上述A类和B类，在A类中声明B类为其友元类，那么可以在B类中直接
访问A类的私有成员变量，但想在A类中访问B类中私有的成员变量则不行。
友元关系不能传递

如果C是B的友元， B是A的友元，则不能说明C时A的友元。

友元关系不能继承

内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系

class A
{
public:
	A()
		:_a(10)
		,_b(20)
	{
		
	}
	class B
	{
		public:
			B(const A a)
			{
				cout << a._a << a._b << endl;
			}
		
	};

private:
	int _a;
	int _b;
};


int main()
{
	A a;
	A::B b(a);


	return 0;
}

匿名对象：
匿名对象不用起名字，但是匿名对象的生命周期只存在调用的那一行：

使用方法：
类名().函数名