C++学习笔记1——入门篇

入门

学习教程：https://www.imooc.com/learn/342

1. 进制：

cout<<oct<<x<<endl;  //八进制
cout<<dec<<x<<endl;  //十进制
cout<<hex<<x<<endl;  //十六进制

2. bool值

cout<<boolalpha<<y<<endl;  //y为bool型，以布尔方式将值输出

3. namespace

#include <stdlib.h>
#include <iostream>
using namespace std;  //用std命名空间是为了用cin和cout

namespace A
{
	int x=1;
	void fun()
	{
		cout<<"A"<<endl;
	}
}
namespace B
{
	int x=2;  //与namespaceA有相同的变量名
	void fun()  //与namespaceA有相同的函数名
	{
		cout<<"B"<<endl;
	}
}
	void fun2()  //与namespaceA不同的函数名
	{
		cout<<"2B"<<endl;
	}
}

using namespace B:  //未指定的情况下默认使用namespaceB

int main()
{
	cout<<A::x<<endl;  //输出namespaceA下定义的变量x
	B::fun();  //调用namespaceB下的函数fun()
	fun2();  //该函数只在B中有定义，在A中没有，无冲突，前面说了默认使用B的，不用再加  B：：
	return 0;
}

入门2

教程：https://www.imooc.com/learn/381

别名

对b进行更改，a也会随之更改，以上输出结果是10不是3

指针类型的引用

*q = 20相当于 *p = 20 相当于a = 20
cout a得20
因为q是p的别名，p指向a

引用作函数参数

左边是用普通方法进行a、b的交换，右边是用引用

引用 举例：

int main()
{
	int a = 10; //没有这句是不成立的，不能只有别名
	int &b = a; //b是a的别名
	b = 20; //此时a也是20
	cout << a << endl; 
	a = 30; // 此时b的值也是30
	cout << b << endl; 
	return 0;
}

引用 举例（结构体）：

typedef struct
{
	int x;
	int y;
}Coord;

int main()
{
	Coord c;
	Coord &c1 = c; //c1是c的别名
	c1.x = 10;
	c1.y = 20; //c相应的x和y也变为10和20
	cout << c.x <<" , " << c.y << endl; 
	return 0;
}
	

引用 举例（指针）:

int main()
{
	int a = 3;
	int *p = &a;
	int *&q = p;

	*q = 5;
	cout << a << endl; //输出的a为5
}

引用 举例（函数）：

void fun(int &a, int &b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}

int main()
{
	int x = 10;
	int y = 20;
	cout << x <<" , " << y << endl;
	fun(x,y);
	cout << x <<" , " << y << endl;
	return 0;
}

结果：x，y值交换

const

第三句（const 在 * 后）跟前两句（const在 * 前）有区别

const修饰的是 *p ，所以p可以改变， *p 不能

const修饰的是p

前后都有const，p和 *p 都不能改

“const int x = 3; int *y = &x;” （X）
用可变的指向不可变的（用权限大的指向权限小的），是不允许的
可改为const int const *y = &x ，也可以改为 int const *p = &x;
“int x = 3; const int *y = &x;” （√）
用权限小的指向权限大的，是允许的

举例：

int main()
{
	const int x = 3;
	//x = 5; //这句话是错的，x不能修改
}

在头文件写#define X 3 效果一样，但没有类型定义，且是宏编译，计算机不会检查语法错误

举例（用指针）：

int main()
{
	int x = 3;
	int const *p = &x; //相当于 ： const int *p = &x;
	//*p = 5; //此句会报错
	x = 5; //此句可以通过
	
	int y = 5;
	int *const q = &y;
	//q = &y; //const修饰的是q，此句会报错
	*q = 20; //是对的，可以通过*p对y进行修改
	cout << y << endl; //输出为20
	
	int z = 3;
	int a = 1;
	int const *s = &z;
	cout << *s << endl; //此句输出3
	s = &a;
	cout << *s << endl;//此句输出1
	
	int b = 3;
	int c = 5;
	int const &d = b; //引用d不可改，b还可以改
	//d = 10; //如果上句没有const，则可通过，输出10。但上句加了const，此句错
 	

举例（用函数）：

void fun (const int &a,const int &b)
{
	a = 10;
	b = 20;
}
int main()
{
	int x = 3;
	int y = 5;
	fun (x,y); //如果函数形参不加const，则没有错误，此句使x=10,y=20。但加了const，则不通过，fun内不能给形参赋值

函数参数默认值

函数重载

内联函数

举例（函数参数默认值、函数重载）：

void fun (int i=10, int j=20, int k=30);
void fun (double i,double j);

int main()
{
	fun(); //全部都是默认值
	fun(100); //i=100，其余默认值
	fun(100,200); //i=100,j=200,k为默认值
	fun(100,200,300); //i=100,j=200,k=300

	fun(1.1,2.2); //两个参数都是double型，判断是使用重载函数
	fun (1,2); //两个参数都是int型，判断是使用第一个fun函数
	return 0;
}

void fun(int i, int j, int k)
{
	cout << i << " " << j << " " << k << endl;
}
void fun(double i, double j)
{
	cout << i << " " << j << endl;
}

内存管理

举例：

int main()
{
	int *p = new int(20);
	//或：int *p = new int;  *p = 20;
	if (p == NULL)
	{
		return 0;
	}
	cout << *p << endl;
	delete p;
	p = NULL;


	int *q = new int[1000];
	if (q == NULL)
	{
		return 0;
	}
	p[0] = 10;
	p[1] = 20;
	cout << q[0] << " " << q[1] << endl;
	delete []q; //如果没有[]，则只释放数组第一个数的空间
	q = NULL;
	
	return 0;
}

举例使用：

#include <string.h>
#include <iostream>
using namespace std;
int main(void)
{
    //在堆中申请100个char类型的内存
    char *str = new char[100];
    //拷贝Hello C++字符串到分配的堆中的内存中
	strcpy(str, "Hello imooc");
    //打印字符串
    cout << str << endl;
    //释放内存
	delete []str;
    str = NULL;
	return 0;
}