C/C++命名空间引用知识

标准命名空间

命名空间的使用

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

// 命名空间必须定义在全局的作用域下
// 命名空间可以嵌套命名空间
// 如果命名空间冲突,则会自动的合并为一个命名空间

namespace zh {
int m_id = 10;
void Display(){ cout << "Display zh func" << endl; }
}

namespace cn {
int m_id = 20;

namespace cpp {
int m_id = 30;
}
}

// 当写了无名空间,相当于写了 static int m_ptr;
// 静态变量只能在当前文件中使用
namespace{ int m_ptr = 10; }

int main(int argc, char* argv[])
{
using namespace zh;
cout << zh::m_id << endl;
cout << cn::m_id << endl;
cout << cn::cpp::m_id << endl;
zh::Display();

system("pause");
return 0;
}

C++ 引用知识

引用的实质就是取别名,&写到左侧叫引用,写到右侧叫取地址。

普通的引用

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{

int a = 10;
int &b = a; // 引用

cout << b << endl;

system("pause");
return 0;
}

数组引用

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{

int ary[10];
for (int x = 0; x < 10; x++)
ary[x] = x;

// 给数组进行取别名
int(&parr)[10] = ary;

// 用别名来输出
for (int y = 0; y < 10; y++)
{
cout << parr[y] << " " ;
}

// 第二种方式取别名
typedef int(ARYS)[10]; // 一个具有10个元素的数组

ARYS &pary2 = ary;
for (int y = 0; y < 10; y++)
{
cout << pary2[y] << " ";
}

system("pause");
return 0;
}

参数传递方式 参数传递两种方式,传递数值,传递地址,还可以传递引用

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

// 指针传递
void mySwap(int *a, int *b)
{
int tmp = *a;

*a = *b;
*b = tmp;
cout << *a << *b << endl;
}

// 引用传递
void myswap2(int &a, int &b)
{
int tmp = a;
a = b;
b = tmp;
}


int main(int argc, char* argv[])
{
int x = 10;
int y = 20;

myswap2(x,y);

cout << x << endl;

system("pause");
return 0;
}

引用传递注意事项 int a = 10; 改成static 即可实现不销毁。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

int& dowork()
{
int a = 10; // 局部变量,返回前销毁了,引用就不存在了
return a;
}


int main(int argc, char* argv[])
{
int &ret = dowork(); // 编译器做了优化,如果打印多次就会出现乱码

cout << ret << endl; // 10
cout << ret << endl; // 乱码了
cout << ret << endl;
cout << ret << endl;
cout << ret << endl;

// 引用可以作为左值使用
dowork() = 1000; // 相当于写了 a = 1000;

system("pause");
return 0;
}

引用的本质: 引用所占用的内存地址与指针类似,引用本质就是指针常量

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

void test(int& ref)
{
ref = 1000;
}

int main(int argc, char* argv[])
{

int a = 10;
int& aref = a; // 指针常量必须初始化,内部是一个指针常量

aref = 20; // 地址不可改

cout << a << endl; // 自动转为 *aref = 20;

cout << aref << endl;

system("pause");
return 0;
}

引用使用场景:指针的引用

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdlib.h>

using namespace std;

struct person
{
int m_age;

};

// 分配空间函数
// **p = > 具体的 person 对象
// *p => 对象的指针
// p => 指针的指针
void allocat(person **p)
{
*p = (person *) malloc(sizeof(person));
(*p)->m_age = 100;

}
// 普通开辟空间写法
void test()
{
struct person *p = NULL;
allocat(&p); // 开始分配内存
cout << "p的:" << p->m_age << endl;
}

// ------------------------------------------------
// 利用指针引用开辟空间
void allocatbyref(person* &p)
{
p = (person *)malloc(sizeof(person));
p->m_age = 1000;
}
void test2()
{
person *p = NULL;
allocatbyref(p);
cout << (*p).m_age << endl;
}

int main(int argc, char* argv[])
{

test2();
system("pause");
return 0;
}

常量引用:

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdlib.h>

using namespace std;

void test()
{
const int &ref = 10; // 加入const后,编译器会处理,创建了一个临时变量,int tmp = 10; const int &ref = tmp;
// ref = 10; 无法直接修改

// 换种方式修改它
int *p = (int*)&ref;
*p = 1000;
cout << ref << endl;
}

int main(int argc, char* argv[])
{
test();
system("pause");
return 0;
}

常量引用使用场景: 用来修饰型can

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdlib.h>

using namespace std;

void test(const int &val) // 不让你修改下
{

cout << val << endl;
}


int main(int argc, char* argv[])
{
int a = 10;

test(a);
system("pause");
return 0;
}

函数与类的一些知识点

内联函数,为了替换c中的宏,内联函数本身也是函数,只是加了一个关键字inline()

编译器会如何除了? 直接变成了宏,直接内嵌到调用的位置,并不增加新的函数。

在类中定义的,成员函数,默认会自动加上内联函数关键字声明,这是编译器为我们加上的。

但是,如果函数过大,或使用了循环等结构,则类则不会声明为内联函数。

#include <iostream>
#include <string>

using namespace std;

inline void compare(int x, int y)
{
int ret = x < y ? x : y;
cout << ret << endl;
}

int main(int argc, char *argv[])
{
compare(10, 20);
system("pause");
return 0;
}

函数的默认参数

#include <iostream>
#include <string>

using namespace std;

void func(int x = 10, int y = 20)
{
cout <<x+y << endl;
}

int main(int argc, char *argv[])
{
func(1, 20);
system("pause");
return 0;
}

函数重载: 名称相同,但是符号不同,后面的参数不同,就是重载。

当使用重载时,编译器会偷偷在前面加上 _func 关键字,这样来使用重载,通过编译检查。

using namespace std;

void func(int x)
{
cout <<x << endl;
}

void func(double x)
{
cout << x << endl;
}

int main(int argc, char *argv[])
{
func(1);
func(1.1);
system("pause");
return 0;
}

extern c 的作用: 在c++ 中想要使用C代码,需要加上extern 关键字。

#include <iostream>
#include <string>

using namespace std;

extern "C" void show()
{
printf("aaaaa \n");
}

int main(int argc, char *argv[])
{
show();
system("pause");
return 0;
}

类的基本定义

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
int uid;
char *name;
int age;

public:
void set(int id,char *name,int age)
{
this->uid = id;
this->name = name;
this->age = age;
}
void display()
{
cout << this->uid << this->name << this->age << endl;
}
};

int main(int argc, char *argv[])
{
Student stu; // 实例化

stu.set(1001, "lyshark", 23); // 设置数据
cout << stu.uid << stu.name << stu.age << endl; // 输出
stu.display(); // 使用成员函数输出

Student *ptr = &stu; // 使用指针
cout << ptr->uid << ptr->name << ptr->age << endl;

system("pause");
return 0;
}

C语言实现的类: 这个是不是看起来很麻烦了,我们继续改进。

#include <iostream>
#include <string>

using namespace std;

struct Student
{
char name[64];
int age;
};

void PrintPerson(struct Student *ptr)
{
printf("Name: %s --> Age: %d \n", ptr->name, ptr->age);
}

int main(int argc, char *argv[])
{
struct Student stu;

strcpy(stu.name, "lyshark");
stu.age = 23;
PrintPerson(&stu);

system("pause");
return 0;
}