标准命名空间
命名空间的使用
#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;
}