C++学习（1）

一、C++概述（了解）

C++在C语言的基础上添加了面向对象编程和泛型编程的支持

二、helloword程序（掌握）

#define _CET_SECURE_NO_WARNINGS//在开发软件visual studio编译 c文件时, visual studio认为strcpy,scanf等函数不安全的导致报警告和错误，导致无法编译通过。
#include //引入头文件
using namespace std;//标准命名空间
int main()
{
    //C++在C语言的基础上添加了面向对象和泛型编程的支持
    //cout是标准的输出流对象，打印字符串
    //endl是刷新缓冲器，并换行
    cout << "helloword"<
    system("pause");//意思就是让程序暂停一下，然后按任意键继续，初学的时候最多见于程序的末尾处，用于看运行结果，避免程序一闪而过。
    return 0;
}

三、面向对象的三大特性（了解）

    封装 把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏（把函数和变量写在类里面，并给他们权限）
    继承 继承所表达的是类之间相关的关系，这种使得对象可以继承另外一类对象的特征和能力。减少代码和数据冗余
    多态 一个接口，多个方法

四、命名空间

    1.为什么有命名空间：是因为解决多人合作是取标识符是重命名（名称冲突）的问题
    2.什么是命名空间：

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;
namespace A {//命名空间,A是空间的名字
    int a;
    void func() {}
}
namespace Maker {
    int a;
    namespace B{
        int b;
    }
}
namespace Maker {//这个Maker和上面的Maker是一个命名空间
    int c;
}
int main()
{
    system("pause");
    return 0;
}

命名空间的注意

1.命名空间只能写在全局
2.命名空间可以嵌套命名空间
3.命名空间是开放，随时可以加入新成员，但是新成员只能在加入后使用
4.匿名的命名空间
5.命名空间可以取别的名字
6.分文件编写代码时，如果.h中有两个命名空间，但是里面的成员函数或者成员变量同名时，在.cpp中实现函数时，需要加上命名空间；

头文件

#pragma once
//.h 和.cpp的区别
// 函数的 .h声明 .cpp实现
//一、用法不同
//1、.h文件直接#include到需要的.cpp文件里，就相当于把.h文件的代码拷贝到.cpp文件
//2、.cpp文件需要先自己生成.o文件，把不同.o文件连接生成可执行文件。
//比如有3个cpp文件：a.cpp、b.cpp、c.cpp，其中一个包含main()函数，需要生成test程序，
//步骤：
//(1）生成3个.o文件：
//	cc - c a.cpp
//	cc - c b.cpp
//	cc - c c.cpp
//	这样就得到3个.o文件：a.o、b.o、c.o
//	(2)链接生成test程序：cc - o test a.o b.o c.o
//	就得到test可执行程序，输入. / test就可执行程序了。
//	二、规范不同
//	1、h文件一般包含类声明；
//	2、cpp文件一般为同名h文件定义所声明的类函数。
//	说明：一般可在cpp文件直接添加main()就可以测试该模块功能。
#include
using namespace std;
namespace myMaker1 {
	//int ma;//定义变量会报错，在.cpp中引入.h相当于将.h中的文件复制过去，所以就存在ma多次定义了，出现变量MM重复的问题；
	void func();
}
namespace myMaker2 {
	void func();
}
class test
{
};
 

源文件

#define _CET_SECURE_NO_WARNINGS
#include 
#include "03test.h"
using namespace std;
//using 声明可使得指定的标识符可用
void test() {
    cout << "namespace Maker c" << Maker::c << endl;
}
namespace Maker {
    int c = 100;
    namespace B {
        int b = 200;
    }
}void test01(){
    //新名字 旧名字
    namespace nameMaker = Maker;//在合作项目当中别人的命名空间和你的一样的时候，你可以给自己的命名空间取别名
    cout << nameMaker::B::b << endl;
}
void test1() {
    cout << "namespace Maker c" << Maker::c << endl;
}
//类似与static int d=50；只允许该文件使用的变量
namespace {
    int d=50;
}
int mya = 10;//C语言中局部变量存在栈里，全局变量存静态存储区。
//局部变量在栈空间上分配，这个局部变量所在的函数被多次调用时，每次调用这个局部变量在栈上的位置都不一定相同。局部变量也可以在堆上动态分配，但是记得使用完这个堆空间后要释放之。
//全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。在程序执行过程中它们占据固定的存储单元，而不动态地进行分配和释放；
int main()
{
    int mya = 20;
    //就近原则
    cout << "mya=" << mya << endl;//20
    cout << "::mya" << ::mya << endl;//10
    cout << "namespace Maker c" << Maker::c << endl;//：：作用域运算符 用来访问某个作用域里面的成员
    cout << Maker::B::b << endl;
    cout << d << endl;//50
    //test1();//会报错，因为声明命名空间在函数之后
    test1();
    //代码变为可执行程序的四步：预处理 编译 汇编 链接（报错中出现无法解释的外部命令说明链接出现了问题）
    myMaker1::func();//myMaker1为头文件中的命名空间
    system("pause");
    return 0;
}
//两个同名的变量，一个全局变量一个局部变量，那局部变量在前期作用域具有较高的优先权，它能屏蔽全局变量

五、using声明和编译指令（重点）

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;//要使用iostream就要将对应的命名空间引入
namespace A
{
    int a = 10;
    int b = 20;
    int c = 30;
}
void test01() {
    //using声明是让命名空间中某个标识符可以直接使用，就等于直接把int a = 10;给替换过来，就成为了局部变量
    using A::a;
    cout << a<
    //int a = 50;//注意：using声明了某个变量，在该作用域不能定义同名的变量
}
void test02()
{
    //using编译指令，让某个命名空间的标识符都可以直接使用
    using namespace A;
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    int a = 100;//为什么不会冲突；
    //类似于命名空间中的a是全局变量，此处的a是局部变量
    cout << a << endl;
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

六、struct类型加强（重点）

加强一  c中定义结构体需要加上struct关键字，C++不需要

加强二  c中结构体中只能定义成员变量，不能定义成员函数。C++既可以定义成员变量也可以定义成员函数

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;
//加强一
//这是自定义的数据类型
struct Maker//没有分配空间，因为这只是一个数据类型
{
    char name[64];
    int age;
};
void test01() {
    //int 只是一个数据类型，只写int没有分配空间
    Maker a;//这时候才进行分配命名空间，不需要加struct就可以定义变量
    
}
//加强二
struct Maker2
{
    int a;
    void func() {//结构体内可以写函数
        cout << "func" << endl;
    }
};
void test02(){
    Maker2 a2;
    a2.func();
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

七、更严格的类型转换（了解）

不能隐式转换，必须是显示的转换

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;
int main()
{
    //不能进行隐式转换，只能进行显示转换
    //char* p = malloc(64);//报错；c中是可以这样写的但是C++数据类型是比较严格的
    char* p = (char*)malloc(64);//malloc返回的是void *  malloc分配的内存大小至少为参数所指定的字节数
    system("pause");
    return 0;
}

八、三目运算符（了解）

C++案例

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;
void test()
{
    int a = 10;
    int b = 20;
    (a > b ? a : b) = 100;
    //C语言的三目运算符返回的是右值
    //C++的三目运算符返回的是左值是空间
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
}
int main()
{
    test();
    system("pause");
    return 0;
}

C案例

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
void test()
{
	int a = 10;
	int b = 20;
	printf("%d\n", a > b ? a : b);
	//( a > b ? a : b)=100//错误
	//这个表达式返回的右值是数值，返回的是20
	//20=100
	*(a > b ? &a : &b) = 100;
	printf("b=%d\n", b);
}
int main()
{
	test();
	return 0;
}

九、C/C++的const（重点）

const变量为常量，不能直接修改，可以间接修改。

C++案例

C++语言的const修饰的变量有时候有空间，有时候没有空间（发生常量折叠，且没有对变量进行取地址操作）

C++语言中const修饰的全局变量具有内部链接属性，只能在当前文件使用。要使用外部链接的话两侧都加extern即可

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;
const int a = 100;//没有内存
void test()
{
    //发生了常量折叠
    cout << "a:" << a << endl;//在编译阶段，编译器cout << "a:" << 100 << endl; 速度更快
    cout << "&a:" << &a << endl;
    //volatile禁止优化
    volatile const  int bb = 20;//栈区
    int* p = (int*)&bb;//进行了取地址操作，所以有空间
    *p = 2000;
    cout << "bb:" << bb << endl;//优化的时候为20 编译器直接修改cout << "bb:" << 20 << endl; 编译器的问题  添加volatile后为2000
    cout << "*p" << *p << endl;//2000
    cout << "bb的地址" << (int)&bb << endl;
    cout << "p指向的地址" << (int)p << endl;
}
int main()
{
    test();
    system("pause");
    return 0;
}

C++编译器不能优化数据的情况

1.如果用变量给const修饰的局部变量赋值，那么编译不会优化

2.不能优化自定义数据类型

#define _CET_SECURE_NO_WARNINGS
#include 
using namespace std;
void test() {
    int a = 10;
    const int b = a;
    int *p = (int *)&b;
    *p = 100;
    cout << "b=" << b << endl;
    cout << "*p=" << *p << endl;
}
//自定义数据类型，编译器不能优化
struct Maker{
	Maker(){//构造函数
		a = 100;
	}
	int a;
};
void test02(){
	const Maker ma;//实例化对象，并初始化a
	cout << ma.a<
	Maker *p = (Maker *)&ma.a;
	p->a=200;
	cout<//没有优化，因为不能优化自定义数据类型
}
int main()
{
    //test();
	test02();
    system("pause");
    return 0;
}

C案例

全局的const不能直接修改也不能间接修改

局部的const不可以直接修改但是可以间接修改

C语言的const修饰的全局变量具有外部链接（extern）属性

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
const int a = 10;//常量区，一旦初始化，不能修改
int main()
{
	//C语言的const修饰的变量都有空间
	不能直接修改全局常量
	//a = 200;
	也不能间接修改全局常量
	//int *p = (int*)&a;
	//*p = 100;
	//printf("%d\n",a);
	const int b = 20;//栈区
	//b = 200;//不能直接修改局部常量
	int *p = &b;//可以间接修改局部常量
	*p = 200;
	printf("%d\n", b);
	//使用别的文件的全局const修饰的变量需要声明
	extern const int c;//C语言的const修饰的全局变量具有外部链接属性
	printf("%d\n", c);
	system("pause");//让程序暂停一下
	return 0;
}