C++入门基础

最新推荐文章于 2026-06-24 20:09:52 发布

原创最新推荐文章于 2026-06-24 20:09:52 发布 · 302 阅读

9 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#c++ #算法 #开发语言

一.命名空间

namespace(避免调用的时候冲突)

#include<stdio.h>
int rand = 10;

int main()
{
	printf("%d", rand);
	
	return 0;
}

rand在原定义为指针，报错重定义；

解决方式

#include<stdio.h>
namespace list 
{
	int rand = 10;
}
int main()
{
	printf("%d", list::rand);
	
	return 0;
}

1.定义

a.namespace +名字+{定义内容} 注：无分号；

b.namespace定义的一个域独立，不影响全局变量；

c.namespace不影响生命周期。

d.name只能定义到全局，可以嵌套定义；

#include<stdio.h>
namespace list
{
	namespace once
	{
		int rand = 9;
		int Add(int x, int y)
		{
			return x + y;
		}
	}
	namespace two
	{
		int rand = 8;
		int Add(int x, int y)
		{
			return 10 * (x + y);
		}
	}
}
int main()
{
	int rand = 19;
	printf("%d\n", rand);
	printf("%d %d", list::once::rand, list::two::rand);
	return 0;
}

e.namespace+命名。如果命名相同，自动合并，实为一个命名空间

f.C++标准库都放在⼀个叫std(standard)的命名空间中

二.命名空间使⽤

1.直接访问

命名空间+：：

namespace list
{
	int rand = 9;
	namespace list1
	{
		int rand = 8;
	}
}
int main()
{
	int rand = 0;
	printf("%d %d %d", rand, list::rand, list::list1::rand);
	return 0;
}

2.using 展开namespace某个成员

amespace list
{
	int rand = 9;
	namespace list1
	{
		int rand = 8;
	}
	int nest = 99;
}
using list::rand;

int main()
{
	printf("%d", rand);
	return 0;
}

3.展开全部(不推荐,展开时需要加namespace+命名，而展开部分只要命名)；

namespace list
{
	int rand = 9;
	namespace list1
	{
		int rand = 8;
	}
	int nest = 99;
}
using namespace list;
int main()
{
	printf("%d", rand);
	return 0;
}

三：C++输⼊&输出

1.<iostream>输入，输出库；

2.std::cin 是istream中的窄字符输入流；

#include <iostream>
int main()
{
	int a = 0;
	double b = 0.0;
	std::cin >> a >> b;
	std::cout << a << b << std::endl;
	return 0;
}

3.std::count输出流

4.std::endl换⾏字符加刷新缓冲区

5.<<流插入 >>流输出

6.无需判断数据类型，可以直接输入输出

7.cout/cin/endl都在std命名空间中

8.cout/cin/endl可以展开使用；

#include <iostream>

using std::cin;

using std::cout;
int main()
{
	int a = 0;
	double b = 0.0;
	cin >> a >> b;
	cout << a << b << '\n';
	return 0;
}

9.可以将std全部展开，不推荐；

using namespace std;

10.<iostream>中包含了<stdio.h>

11.提高效率

#include<iostream>
using namespace std;
int main()
{
// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
// 可以提⾼C++IO效率
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}
1

四.缺省参数

a.给参数值则使用该值，or使用默认值

b.半缺省只能从右往左缺省；

c.给值从左往右

d.缺省参数在声明给值

1.全缺省

#include <iostream>
void Fun(int a=8, int b=7, int c=6)
{
	std::cout << "a==" << a<<std::endl;
	std::cout << "b==" << b<<std::endl;
	std::cout << "c==" << c<<std::endl;

}
int main()
{
	Fun();
	Fun(7, 0, 8);
	return 0;
}

2.半缺省（只能从右到左缺省）

#include <iostream>
void Fun(int a , int b = 7, int c = 6)
{
	std::cout << "a==" << a << std::endl;
	std::cout << "b==" << b << std::endl;
	std::cout << "c==" << c << std::endl;

}
int main()
{
	Fun(3);
	Fun(8);
	Fun(4, 4, 9);
	return 0;
}

五.函数重载

1.返回类型不同

#include <iostream>
int Add(int a, int b)
{
	return a + b;
}
double Add(double a, double b)
{
	return a + b;
}
int main()
{
	int c = Add(3, 8);
	double d = Add(3.9, 8.9);
	printf("%d %lf", c, d);
	return 0;
}

2.个数不同

#include <iostream>

void Fun(int a)
{
	std::cout << a << std::endl;
}
void Fun()
{
	std::cout << "空" << std::endl;
}
int main()
{
	Fun(4);
	Fun();
	return 0;
}

3.顺序不同

#include <iostream>
void Fun(int a, double b)
{
	std::cout << a << b << std::endl;
}
void Fun(double b, int a)
{
	std::cout << b << a << std::endl;
}
int main()
{
	Fun(2, 7.9);
	Fun(7.9, 2);
	return 0;
}

六：引用

特性

a.对象要初始化

b.对象可以被多个引用

c.只可引用一次

数据类型+&=引用对象

#include <iostream>
int main()
{
	int a = 9;
	int& b = a;
	int& c = b;
	int& d = c;
	std::cout << a << std::endl;
	std::cout << b << std::endl;
	std::cout << c<< std::endl;
	std::cout << d << std::endl;

	return 0;
}

引⽤的使⽤

#include <iostream>
void swap(int& a, int& b)
{
	int tamp = a;
	a = b;
	b = tamp;
}
int main()
{
	int a = 9;
	int b = 8;

	swap(a, b);
	printf("%d %d", a, b);
	return 0;
}

七.const引用

1.可以引用const对象，可以放小，不可放大

int main()
{
	//权限不变
	const int a = 9;
	//权限放大——错误
	//int& e = a;
	const int& b = a;
	//权限放小
	int c = 8;
	const int d = c;
	//
	return 0;
}

2.当被引用对象在零时对象时，会触发放大权限

int main()
{
	int a = 8;
	const int& b = 3*a;
	double b = 9.0;
	const int& d = b;
	return 0;
}

3.临时对象：编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象

八：指针和引⽤的关系

1.引用不开空间，指针开空间

2.引用对象初始化，指针不需要

3.引用后不可以引用其他对象，指针可以指多个对象

4.引用可以直接访问，指针不可以

5.引用引用大小为引用对象相同，指针为4（32平台）指针8（64平台）；

6.引用不容易出现野引用，指针容易出现。

九inline

1.用inline修饰的函数，在调用时会展开，提高效率；

2.短小的函数会展开，长的会忽略；

3.因为define容易出错，因此用inline替代

4.debug内联函数不展开，需手动操作。

5.inline不要放在两个文件中。

#include <iostream>
inline int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int c = Add(2, 9);
	printf("%d", c);
	return 0;
}

十.nullptr

1.c++中NULL定义为零，因此传指针时可能会出错。

2.nullptr为关键字，可转换为任意指针类型

#include <iostream>
void F(int x)
{
	std::cout << "int" << std::endl;
}
void F(int* x)
{
	std::cout << "int*" << std::endl;
}
int main()
{
	F(9);
	F(NULL);
	F(nullptr);
	return 0;
}