c++核心编程复习_Day1

已于 2024-04-06 19:55:56 修改
阅读量132 收藏 1
点赞数
文章标签： c++ 蓝桥杯 开发语言
于 2022-01-18 15:34:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55858644/article/details/122552532
版权

目录

双冒号作用域运算符

namespace 作用域

using声明以及using编译指令

c++对c语言的拓展(一)

c++对c语言的拓展(二)

 const连接属性

const分配内存情况

引用的基本语法

参数传递方式及引用的注意事项

指针的引用

常量的引用

双冒号作用域运算符

::代表作用域  如果前面什么都不添加 代表全局作用域

int atk = 1000;
void test01()
{
	int atk = 2000;
	cout << "atk=" << atk << endl;
	cout << "全局 atk" << ::atk << endl;
}

namespace 作用域

//1、命名空间用途： 解决名称冲突
void test01()
{
	KingGlory::goAtk();

	LOL::goAtk();
}

//2、命名空间下 可以放  变量、函数、结构体、类...
namespace A
{
	int m_A;
	void func();
	struct Person
	{};
	class Animal
	{};
}

//3、命名空间 必须要声明在全局作用域下
void test02()
{
	//namespace B{}; 不可以命名到局部作用域
}

//4、命名空间可以嵌套命名空间
namespace B
{
	int m_A = 10;
	namespace C
	{
		int m_A = 20;
	}
}
void test03()
{
	cout << "B空间下的m_A = " << B::m_A << endl;
	cout << "C空间下的m_A = " << B::C::m_A << endl;
}

//5、命名空间是开放的，可以随时给命名空间添加新的成员
namespace B
{
	int m_B = 100;
}
void test04()
{
	cout << "B空间下的m_A = " << B::m_A << endl;
	cout << "B空间下的m_B = " << B::m_B << endl;
}

//6、命名空间可以是匿名的
namespace
{
	int m_C = 1000;
	int m_D = 2000; 
	//当写的命名空间的匿名的，相当于写了  static int m_C = 1000; static int m_D = 2000;
}

void test05()
{
	cout << "m_C = " << m_C   << endl;
	cout << "m_D = " << ::m_D << endl;
}

//7、命名空间可以起别名
namespace veryLongName
{
	int m_E = 10000;
	void func()
	{
		cout << "aaa" << endl;
	}
}

void test06()
{
	namespace veryShortName = veryLongName;
	cout << veryShortName::m_E << endl;
	cout << veryLongName::m_E << endl;

}

using声明以及using编译指令

namespace KingGlory
{
	int sunwukongId = 1;
}

namespace LOL
{
	int sunwukongId = 3;
}

void test01()
{
	int sunwukongId = 2;

	//1、using声明
	//using KingGlory::sunwukongId ;  

	//当using声明与 就近原则同时出现，出错，尽量避免
	cout << sunwukongId << endl;

}


void test02()
{
	//int sunwukongId = 2;
	//2、using编译指令
	using namespace KingGlory;
	using namespace LOL;
	//当using编译指令  与  就近原则同时出现，优先使用就近
	//当using编译指令有多个，需要加作用域 区分
	cout << KingGlory::sunwukongId << endl;
	cout << LOL::sunwukongId << endl;
}

c++对c语言的拓展(一)

//1、全局变量检测增强
int a;
int a = 10;

//2、函数检测增强  返回值没有检测  形参类型没有检测   函数调用参数个数没有检测
getRectS( w  , h)
{

	return w *h;
}
void test01()
{
	printf("%d\n", getRectS(10, 10, 10));
}


//3、类型转换检测增强
void test02()
{
	char * p = malloc(64);
}


//4、struct增强
struct Person
{
	int age;
	//void func(); C语言下 结构体不可以有函数
};

void test03()
{
	struct Person p; //创建结构体变量时候，必须加关键字struct
	p.age = 100;
}


//5、bool类型扩展  C语言下 没有这个类型
//bool a;


//6、三目运算符增强
void test04()
{
	//?:
	int a = 10;
	int b = 20;

	printf("ret = %d\n", a > b ? a : b);

	*(a > b ? &a : &b) = 100;  //C语言下 返回的是值  20 = 100

	printf("a = %d\n", a);
	printf("b = %d\n", b);

}


//7、const增强
//全局const
const int m_A = 100; // 受到常量区保护，运行修改失败

void test05()
{
	//m_A = 200;
	//int * p = &m_A;
	//*p = 200;

	//局部const
	const int m_B = 100; //分配到栈上
	//m_B = 200;
	int * p = &m_B;
	*p = 200;

	printf("%d\n", m_B);

	//int arr[m_B]; 在C语言下 const是伪常量，不可以初始化数组

}

c++对c语言的拓展(二)

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//1、全局变量检测增强  C++检测出重定义
int a;
//int a = 10;

//2、函数检测增强 返回值检测、形参类型检测、函数调用参数个数
int getRectS(int w,int h)
{

	return w *h;
}
void test01()
{
	printf("%d\n", getRectS(10, 10));
}


//3、类型转换检测增强
void test02()
{
	char * p = (char *)malloc(64);
}

//4、struct增强  C++可以放函数，创建结构体变量，可以简化关键字 struct
struct Person
{
	int age;
	void func()
	{
		age++;
	}
};

void test03()
{
	Person p;
	p.age = 17;
	p.func();
	cout << "p的age = " << p.age << endl;
}

//5、bool类型扩展  C语言下 没有这个类型  C++有bool类型
bool flag = true; // bool类型 代表  真和假   true  ---- 真(1)    false  ---- 假(0)

void test04()
{
	cout << sizeof(bool) << endl; //结果是1个字节
	//flag = false;
	//flag = 100; //将非0的数都转为1
	cout << flag << endl;
}

//6、三目运算符增强
void test05()
{
	//?:
	int a = 10;
	int b = 20;

	printf("ret = %d\n", a > b ? a : b);

	(a < b ? a : b )= 100; // C++下返回的是变量  b = 100

	printf("a = %d\n", a);
	printf("b = %d\n", b);
}


//7、const增强
//全局const   和C语言结论一致
const int m_A = 100;
void test06()
{
	//m_A = 200;
	//int * p = (int *)&m_A;

	//*p = 200;


	//局部const
	const int m_B = 100;
	//m_B = 200;
	int * p = (int *)&m_B;
	*p = 200;
	cout << "m_B = " << m_B << endl;

	int arr[m_B]; //C++下const修饰的变量 称为常量 ，可以初始化数组

}


int main(){
	//test01();
	//test03();
	//test04();
	//test05();
	test06();


	system("pause");
	return EXIT_SUCCESS;
}

 

 const连接属性

C语言下const修饰全局变量默认是外部链接属性

//test1.c
const int g_a = 1000;
//-----------------------------
//test2.c
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int main(){

	extern const int g_a; 

	printf("g_a = %d\n", g_a);

	system("pause");
	return EXIT_SUCCESS;
}

//test1.cpp
extern const int g_b = 1000;//默认是内部链接属性 可以加关键字 extern 提高作用域
//---------------------
//test2.cpp
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

int main(){

	extern const int g_b;

	cout << "g_b = " << g_b << endl;;

	system("pause");
	return EXIT_SUCCESS;
}

const分配内存情况

  1. const分配内存情况
    1. 对const变量 取地址 ，会分配临时内存 
    2. 使用普通变量  初始化 const变量
    3. 对于自定义数据类型
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>

//1、对const变量 取地址 ，会分配临时内存  
void test01()
{
	const int a = 10;
	int * p = (int *)&a;
}

//2、使用普通变量  初始化 const变量
void test02()
{
	int a = 10;
	const int b = a;

	int *p = (int *)&b;
	*p = 1000;

	cout << "b = " << b << endl;

}

//3、对于自定义数据类型 
struct Person
{
	string m_Name;
	int m_Age;
};
void test03()
{
	const Person p;
	//p.m_Age = 10;

	Person * pp = (Person *)&p;
	(*pp).m_Name = "Tom";
	pp->m_Age = 10;

	cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}


int main(){

	//test02();
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

引用的基本语法

    1. 目的：起别名
    2. 语法： 类型（与原名类型必须一致）   &别名  =  原名
    3. 引用必须要初始化
    4. 引用一旦初始化后，就不可以引向其他变量
    5. 建立对数组引用
      1. 直接建立引用
      2. int arr[10];
      3. int(&pArr)[10] = arr;
    6. 先定义出数组类型，再通过类型 定义引用
      1. typedef int(ARRAY_TYPE)[10];
      2. ARRAY_TYPE & pArr2 = arr;
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//引用基本语法：  类型  &别名 = 原名
void test01()
{
	int a = 10;
	int &b = a;

	b = 100;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}


void test02()
{
	int a = 10;
	//int &b; //引用必须要初始化

	int &b = a;

	//引用一旦初始化后，就不可以引向其他变量

	int c = 100;

	b = c; // 赋值

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

//对数组建立引用
void test03()
{
	//1、直接建立引用
	int arr[10];
	int(&pArr)[10] = arr;

	for (int i = 0; i < 10; i++)
	{
		arr[i] = 100 + i;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << pArr[i] << endl;
	}


	//2、先定义出数组类型，再通过类型 定义引用
	typedef int(ARRAY_TYPE)[10];
	//类型  &别名 = 原名
	ARRAY_TYPE & pArr2 = arr;

	for (int i = 0; i < 10; i++)
	{
		cout << pArr2[i] << endl;
	}

}

int main(){

	//test01();
	//test02();
	test03();

	system("pause");
	return EXIT_SUCCESS;
}

参数传递方式及引用的注意事项

  1. 参数的传递方式
    1. 值传递
    2. 地址传递
    3. 引用传递
  2. 注意事项
    1. 引用必须引一块合法内存空间
    2. 不要返回局部变量的引用
    3. 当函数返回值是引用时候，那么函数的调用可以作为左值进行运算
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//1、值传递
void mySwap01(int a  , int b)
{
	int temp = a;
	a = b;
	b = temp;

	/*cout << ":::a = " << a << endl;
	cout << ":::b = " << b << endl;*/
}

//2、地址传递
void mySwap02(int *a, int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

//3、引用传递
void mySwap03(int &a , int &b) // int &a = a; int &b = b;
{
	int temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	//mySwap01(a, b);
	//mySwap02(&a, &b);

	mySwap03(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

int& func()
{
	int a = 10;
	return a;
}

//引用注意事项
void test02()
{
	//1、引用必须引一块合法内存空间
	//int &a = 10;

	//2、不要返回局部变量的引用
	int &ref = func();
	cout << "ref = " << ref << endl;
	cout << "ref = " << ref << endl;
}

int& func2()
{
	static int a = 10;
	return a;
}

void test03()
{
	int &ref = func2();
	cout << "ref = " << ref << endl;
	cout << "ref = " << ref << endl;
	cout << "ref = " << ref << endl;
	cout << "ref = " << ref << endl;
	//当函数返回值是引用，那么函数的调用可以作为左值
	func2() = 1000;

	cout << "ref = " << ref << endl;


}


int main(){
	//test01();
	//test02();
	test03();



	system("pause");
	return EXIT_SUCCESS;
}

指针的引用

引用的本质在c++内部实现是一个指针常量

    1. 利用引用可以简化指针
    2. 可以直接用同级指针的 引用  给同级指针分配空间
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

struct Person
{
	int age;
};

void allocateSpace(Person ** p)
{
	//p指向指针的指针    *p  指针 指向的是person 本体   **p  person本体
	*p = (Person *)malloc(sizeof(Person));
	(*p)->age = 10;

}

void test01()
{
	Person * p = NULL;
	allocateSpace(&p);

	cout << "p.age = " << p->age <<  endl;
}



void allocateSpace2(Person* &pp) // Person * &pp = p;
{
	pp = (Person *)malloc(sizeof(Person));
	pp->age = 20;
}

void test02()
{
	Person *p = NULL;
	allocateSpace2(p);
	cout << "p.age = " << p->age << endl;
}

int main(){

	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

常量的引用

    1. const int &ref = 10;
    2.  // 加了const之后，  相当于写成   int temp = 10;  const int &ref = temp;
    3. 常量引用的使用场景 修饰函数中的形参，防止误操作

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

void test01()
{
	//int &ref = 10;

	const int &ref = 10; // 加了const之后，  相当于写成   int temp = 10;  const int &ref = temp;

	int *p = (int *)&ref;
	*p = 10000;

	cout << ref << endl;
}

void showValue(const int &a)
{
	//a = 100000;

	cout << "a = " << a << endl;

}
//常量引用的使用场景 修饰函数中的形参，防止误操作
void test02()
{
	int a = 100;
	showValue(a);

}

int main(){

	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

蓝图_BP
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
高质量c++c编程指南_c++编程_
09-29
高质量C++编程指导，将对c++初学者进阶有很大帮助
c++基础
lqjzb的博客
04-05 7572
一、循环结构 1.while循环 ()中填的是循环条件 避免死循环出现 #include<iostream> using namespace std; int main(){ //输出0~9 int num = 0; while (num<10) { cout << num << endl; num++; } system("pause"); return 0; } //结果为0~9的一列 例子：猜数字 #include&l
C++的#include ＜iostream＞详解
2201_75598244的博客
07-24 6800
命名空间是C++的一种机制，用来把单个标识符下的大量有逻辑联系的程序实体组合到一起。包含了iostream也自动包含了ios、streambuf、istream、ostream和iosfwd。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。，在这个函数中用于提取iostream文件中的代码，并编译使用其输出功能。在 cout （输出）中每一个不同类型的数据之间都要用。同时在 cin（输入）中每一个不同类型的数据之间都要用。源文件带来的功能，用于输出“指定数据”到窗口中。
C++入门
qq_55895496的博客
11-07 1732
效果类似与宏函数，不过inline是函数会对函数安全性检查，不过如果程序中大量使用inline会使得编译展开后的源文件庞大，增加内存消耗，减少调用增加内存消耗，一种用空间换时间的想法。声明或定义时为函数的参数指定一个缺省值，（注意这里的或，是异或，不可以&，是二选一）在调用该函数时，如果没有指定参数则采用该形参的缺省值。定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。不使用using，则在要使用时，空间名::成员名；
#include＜iostream＞
小秋 AI SLAM 入门实战教程
05-09 3948
库提供了C++程序中用于处理标准输入/输出流的基本功能。这个库中定义了一些重要的类和对象，以及与输入/输出相关的函数。类：这是一个输入流类，用于从输入设备（如键盘、文件等）读取数据。类：这是一个输出流类，用于向输出设备（如屏幕、文件等）写入数据。这些类分别用于处理字符串流、文件输入流和文件输出流。类型的对象，表示标准错误流。类型的对象，表示标准输入流（通常是键盘输入）。类型的对象，表示标准输出流（通常是屏幕输出）。库还包括了其他与流处理相关的类，例如。类型的对象，表示标准日志流。类似，但用于输出日志消息。
C++基本框架：# include ＜iostream＞
2302_80203140的博客
10-16 640
给代码加上的一些解释部分，不会被编译器识别，不会进入到编译过程中去。单行注释使用 //（文字）多行注释使用 /* （文字）*/
C++ 网络编程_c++网络编程_C++网络编程_
10-02
C++程序设计语言　C++ 网络编程 规范
高质量 C++C 编程指南_C编程规范_高质量C++C编程指南_C++编程规范_
09-29
一些关于C/C++编程时需留意的规范，你可以从中找出你的一些一直习惯用的但隐含错误的方式编程行为，提高软件质量
c++核心编程指南中文版
09-29
c++核心编程指南中文版
WINDOWS核心编程_C++_
10-03
Windows编程核心教程，很有用的，如果你是做与Windows相关的工作
C++标准库头文件解释
yjj1123456的博客
05-13 8218
是C++标准库中的头文件，它提供了许多用于处理字符串的函数和操作。头文件，我们可以使用上述函数和操作来处理字符串，执行各种字符串相关的任务，如复制、连接、比较、查找等。是C++标准库中的头文件，它提供了许多常用的算法函数，用于对数据进行排序、查找、变换和操作等操作。头文件，我们可以使用上述函数和操作来对数据进行各种常见的算法处理，如排序、查找、统计、变换等。是C++编程语言中的一个预处理指令，用于包含 C-style 字符串处理函数的头文件。是C++标准库中的头文件，它包含了输入输出流的定义，包括了。
1、变量、声明、引用(C++核心语法)
伍粟的博客
04-09 452
1 C++概述 1.1 C++两大编程思想 1.1.1 面向对象 1.1.2 泛型编程 1.2移植性和标准 1.2.1 ANSI 在1998制定出C++第一套标准 2 c++初识 2.1 引入头文件 #include <iostream> 标准输入输出流 2.2 使用标准命名空间 using namespace std; 2.3 标准输出流对象 cout << “..” << 1234 << 3.14 << endl; 2.4 面
#include <iostream>是什么意思
weixin_45617478的博客
10-08 2万+
包含c++的标准输入输出头文件iostream 也就是编译器先把头文件iostream中的所有内容COPY到 #include的位置，再进行编译 注意c++的这个标准输入输出头文件的名称就是iostream，没有.h的后缀 跟c的标准输入输出头文件stdio.h不一样。 ...
C++——IOStream
最新发布
qq_74260823的博客
01-23 1956
C++IO流的简单介绍
C++基础知识
weixin_59179454的博客
09-22 866
C——编程思想——函数设计——流程图C++——面向对象思想——类的设计——抽象——类图（UML)1、C++调用 #include 为预处理命令即使用标准名空间中的内容iostream为一个类，包括 istream类——输入流类；ostream类——输出流类cin（输入流对象）——istreamcout（输出流对象）——ostream“”为输出运算符2、命名空间——解决词穷问题实现同一程序内，函数命名相同问题3、 与 “” 的区别。
iostream
UncleJokerly
03-22 2308
#include 是个包含命令，就是把iostream.h这个文件里的内容复制到这个地方ostream.h是input output stream的简写，意思为标准的输入输出流头文件。它包含： （1）cin>>"要输入的内容" （2）cout 这两个输入输出的方法需要#include来声明头文件。 iostream.h与iostream是不同的。 #include是在旧的标准C++中使用
C++1.1 #include＜iostream＞
热门推荐
qq_45698096的博客
01-23 2万+
#include<iostream> //头文件，给予使用部分功能的权限 using namespace std; //为了解决命名冲突的问题而引入的概念 int main() //main函数，每一个C++程序都需要有一个main函数 { cout<<"Hello World"<<endl; //输出Hello World 并转到下一行 system("pause"); //命令系统在
指针和引用的区别
sozenvN的Blog
12-06 740
从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它可以被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。 而引用是一个别名，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化，而且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。 在C++中，指针和引用经常用于函数的参数传递，然而，指针传递参数
黑马程序员c++核心编程
10-24
黑马程序员C++核心编程是一门针对C++语言的深入学习课程，主要包括C++基础语法、面向对象编程、模板、STL等内容。该课程通过理论讲解和实战演练相结合的方式，帮助学员深入理解C++语言的核心概念和编程思想，掌握C++...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值