【C++】初识C++

于 2024-09-20 17:22:14 发布
阅读量602 收藏 18
点赞数 15
分类专栏： C++ 文章标签： c++ C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80035097/article/details/142343308
版权

【C++】初识C++

文章目录

前言

本篇文章将详细讲到C++的初识，双冒号作用域运算符，namespace命名空间，using声明以及using编译指令，C++对C语言的增强和扩展，C++下const 修饰全局变量，const 分配内存情况，引用基本语法，参数的传递形式，指针引用，常量的引用。

一、C++的初识

#include<iostream>	//标准输入输出流   i - input 输入  o - output 输出  stream 流 相当于stdio.h
using namespace std;//使用  标准  命名空间

//程序入口函数
int main()
{
	//cout 标准输出流对象
	// << 左移  在C++下有了新的寓意 用与在cout后拼接输出的内容
	// endl  --- end line  刷新缓冲区 并且换行
	cout << "hello" << endl;

	system("pause"); //阻塞
	return EXIT_SUCCESS;  //返回正常退出

#include; 预编译指令，引入头文件iostream.
using namespace std; 使用标准命名空间
cout << “hello world”<< endl; 和printf功能一样，输出字符串”hello wrold”

二、双冒号作用域运算符

通常情况下，如果有两个同名变量，一个是全局变量，另一个是局部变量，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。
::代表作用域 如果前面什么都不添加 代表全局作用域

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

int atk = 999;

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

}

int main()
{
	test01(); 
	 
	system("pause");
	return EXIT_SUCCESS; 

}

三、namespace命名空间

  1. 命名空间用途 ： 解决名称冲突
  2. 命名空间下 可以放 变量 函数 结构体 类 …
  3. 命名空间 必须要声明在全局作用域下
  4. 命名空间可以嵌套命名空间
  5. 命名空间是开放的，可以随时给命名空间添加新成员
  6. 命名空间可以是匿名的
  7. 命名空间可以起别名
  • game1.h
#pragma once
# include <iostream>
using namespace std;
namespace KingGlory
{
	void goAtk();
}
  • game1.c
#define  _CRT_SECURE_NO_WARNINGS 1
# include "game1.h"

void KingGlory::goAtk() 
{
	cout << "王者荣耀攻击实现" << endl;
}
  • game2.h
#pragma once
#include <iostream>
using namespace std;
namespace LOL
{
	void goAtk();
}
  • game2.c
#define  _CRT_SECURE_NO_WARNINGS 1
# include "game2.h"
void LOL::goAtk()
{
	cout << "LOL攻击实现" << endl;
}

#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include "game1.h"
#include "game2.h"

//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 << veryLongName::m_E << endl;
	cout << veryShortName::m_E << endl;

}

int main()
{
	//test01();
	//test03();
	//test04();
	//test05();
	//test06();
	system("pause");
	return EXIT_SUCCESS;
}

四、using声明以及using编译指令

当using声明与 就近原则同时出现，出错，尽量避免
当using编译指令 与 就近原则同时出现，优先使用就近
当using编译指令有多个，需要加作用域 区分

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

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 << sunwukongId << endl;
	cout << KingGlory::sunwukongId << endl;
	cout << LOL::sunwukongId << endl;
	
}

五、C++对C语言的增强和扩展

1、全局变量检测增强 C++检测出重定义
2、函数检测增强 返回值检测、形参类型检测、函数调用参数个数
3、类型转换检测增强
4、struct增强 C++可以放函数，创建结构体变量，可以简化关键字 struct
5、bool类型扩展 C语言下 没有这个类型 C++有bool类型
6、三目运算符增强
7、const增强

#define  _CRT_SECURE_NO_WARNINGS 1
#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, 19));
}

//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; //结果是一个字节
	flag = false;
	cout << flag << endl;
	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  //结合性 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;//100   

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

}

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


	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

六、C++下const 修饰全局变量

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

  • test.c
const int g_b = 1000;
  • C++下的const修饰的全局变量默认是内部链接属性.cpp
#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;


int main()
{
	extern const int g_b;

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

	system("pause");
	return EXIT_SUCCESS;
}

无法打印出g_b的值 在test.c 文件中 const int g_b = 1000 前加extern 即可在外部文件访问到g_b

七、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;
}

八、引用基本语法

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

#define  _CRT_SECURE_NO_WARNINGS 1
#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、值传递
2、地址传递
3、引用传递

#define  _CRT_SECURE_NO_WARNINGS 1
#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);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	mySwap02(&a, &b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	mySwap03(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}


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



	system("pause");
	return EXIT_SUCCESS;
}

引用的注意事项：
1、引用必须引一块合法内存空间
2、不要返回局部变量的引用
当函数返回值是引用，那么函数的调用可以作为左值

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;
}

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

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;


}

十、指针引用

引用的本质在c++内部实现是一个指针常量
Type& ref = val; // Type* const ref = &val

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

struct Person
{
	int age;
};

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


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 = 19;
}

void test02()
{
	Person* p = NULL;
	allocateSpace2(p);

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

}


int main() {

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

十一、常量的引用

常量引用的使用场景 修饰函数中的形参，防止误操作

#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 = 10000;

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

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

}

int main() {

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

总结

到这里这篇文章的内容就结束了，谢谢大家的观看，如果有好的建议可以留言喔，谢谢大家啦！

冷白白
关注
专栏目录
c++初识
qq_58026813的博客
01-08 303
基础的C++数据类型
1、变量、声明、引用(C++核心语法)
伍粟的博客
04-09 471
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 面
理解C/C++语言的声明语法-声明子
aipimao0605的博客
06-27 164
这是理解C/C++语言的声明语法系列的下半部分，继续阅读之前请先阅读理解C/C++语言的声明语法-声明。 一个声明为每个声明子都声明一个实体（entity）,同时为那个实体给出一个名字，并且隐含的给出存储类，类型，和由说明符给出的其它特性。说明符和声明子一起决定了名字是否是一个对象，数组，指针，引用或函数。例如， 声明x为一个整型指针，f为一个函数返回一个整型。正是声明子*x和f()...
C++学习笔记（一）（变量、声明、定义、引用）
_zhanggx9的博客
04-03 2980
1. 如果把一个超出其取值范围的值赋给一个指定类型的对象时，结果会怎样？ 对于unsigned类型来说，编译器必须调整越界值使其满足要求。编译器会对unsigned类型的可能取值数目求模，然后取得所得值。有些语言中将负数赋予unsigned类型是非法的，但在C++中这是合法的。 对于signed类型来说，很多编译器处理signed类型的方法与unsigned类型类似，但我们并不能保证所有编译器
C++中的声明语句
记录点滴的专栏
09-29 3538
一条声明语句的目的是令程序知晓某个名字的存在以及该名字表示一个什么样的实体，如一个类、一个函数、一个变量等；int a;//声明一个变量 int f();//声明一个函数 class A{ } A a;//声明一个类
初识C++ 初识C++
12-06
初识C++ 初识C++ 初识C++初识C++初识C++初识C++初识C++
每天学点C++（C++实例教程：教程+源码）01C++初识.zip
最新发布
06-21
在“01C++初识”这个部分，我们将首先接触到C++的基础知识。这通常包括以下几个方面： 1. **C++简介**：C++是由Bjarne Stroustrup在C语言基础上发展起来的，它保留了C语言的效率，同时引入了面向对象编程的概念，如...
Android NDK编程C++初识，基本数据类型使用
09-26
在Android开发中，NDK（Native Development Kit）提供了一种方式让开发者可以使用原生代码，比如C++，来编写应用程序的部分或全部功能。这种方式可以让应用受益于原生代码的性能提升，特别是在处理密集计算或者游戏...
C++学习第1课初识C++
12-29
C++是一种广泛应用于系统软件开发、游戏编程、嵌入式系统和高性能计算等多个领域的高级编程语言。它由Bjarne Stroustrup在1983年基于C语言进行扩展和..."第1课初识C++"的内容会涵盖这些基础知识，引导你踏入C++的世界。
C++ 中使用引用类型的成员变量
weixin_33672400的博客
08-25 527
因为引用类型的成员变量定义时需要赋值，不然其所在的类初始化时有编译错误，所以一直以为不能使用引用类型的变量作为成员变量。但在探讨C++的前置声明知识时，发现是可以定义引用类型的成员变量的。如下讲解一下如何使用引用类型的成员变量。//AAA.h #pragmaonce classBBB; classAAA { public: AAA(BBB&...
C++ 类成员引用变量的使用
热门推荐
tzdjzs的专栏
08-05 1万+
      出来工作后，才发现原来C++的类成员变量可以是引用变量。下面通过一个例子来说明（虽然没多大意义）：  #include  using namespace std;class A{public:    A(int i=3):m_i(i){}    void print()    {        cout"m_i="    }p
C++基本语法之——声明与定义
zenny_chen的专栏
10-24 1080
C++基本语法之——声明与定义
11，C++之引用变量
Shao_yihao的博客
05-13 207
引用变量（名词） 引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，用变量名称可以指向变量，也可以使用该引用名称来指向该变量。 引用很容易与指针混淆，它们之间有三个主要的不同： 不存在空引用。引用必须连接到一块合法的内存。 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。 引用必须在创建时被初始化。指针可以在任何时间被初始化。 C++ 中创建引用 试想变量名称是变量附属在内存位置中的标签，可以把引用当成是变量附属在内存位置
C++ 类中的引用成员变量
DirkNow的专栏
03-12 7019
类成员引用。 注意点： 1.必须在初始化列表中指定。 2.所指定的变量的生存期一定要长于改类的生存期。 错误&正确例子： using namespace std; class classB; class classA{ public: //classA(classB p); 错误例子 classA(classB& p); //正确使用 classB &a_obj;
《黑马》——C++核心编程
持之以恒_fighting
11-23 3410
前言 配套视频： https://www.bilibili.com/video/BV1et411b73Z 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++提高编程 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用 1 模板 1.1 模板的概念 模板就是建立通用的模具，大大提高复用性 模板的特点： 模板不可以直接使用，它只是一个框架 模板的通用并不是万能的 1.2 函数模板 C++另一种编程思想称为泛型编程，主要利用..
C++ 类成员变量为引用时如何编写
loy的专栏
11-25 735
C++的成员变量可以为引用吗？答案：是的！ 代码如下： #include using namespace std; class A { public: A(int s):_k(s){cout << "A constructor" << endl;} ~A(){cout << "A destructor" << endl;} void print(){cout <<
C++语法（十一）引用
Hillbox
09-13 215
引用即给变量起别名，初始化如下： int a = 10; int &b = a; 1、改变引用的值，变量也会改变值。 2、引用必须要初始化，不能仅仅声明。 3、引用一旦初始化后就不能再改变，它的本质是指针常量。比如b已是a的引用，就不能改成c的引用了。 要把赋值操作和更改引用区分开。 int &b = a; // 实际上是 int* const b = &a; 4、在函数中的引用传递 void swap1(int *a, int *b){ int tem.
C++ 函数引用
qq_53055705的博客
04-09 5204
函数引用1.概念2.用法3.特性4.常引用5.引用的场景6.传值和传引用的效率比较7.引用和指针的区别： 1.概念 引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用的变量开辟内存空间，它和它引用的变量共用一块内存空间。 2.用法 类型 &引用变量名(对象名) = 引用实体 注意：引用类型必须和引用实体是同种类型的 3.特性 引用在定义时必须初始化 一个变量可以有多个引用 引用一旦引用一个实体，再不能引用其他实体 4.常引用 声明方式：const 类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值