// #include <stdio.h> // C语言的标准支持
#include <iostream> // C++标准支持 C++的与众不同
using namespace std; // 命名空间 C++ 的特性 （Java语言的内部类）
int main() {
// C++语言面向对象 + 标准特性
// C语言面向过程，函数+结构体
// C++里面可以运行C语言，可以调用C语言，反之 就不行C语言无法运行C++
// 小故事：谣言 C++-- 在C语言上增加好的内容
// C++里面可以运行C语言，可以调用C语言，反之 就不行C语言无法运行C++
printf("降龙十八掌(C版)\n");
// std::cout << "C++语言的学习" << std::endl;
cout << "C++语言的学习" << endl; // 因为你前面引入了命名空间，省略std::
// endl == \n 都是换行的含义一样
// Kotlin也有操作符重载， Kotlin就是各个语言的精华所在
// << 不是属性里面的运算，操作符重载，后面会讲
cout << "擒龙功" << endl;
cout << "铁头功\n"
<< "金刚腿\n"
<< "铁布衫\n";
return 0;
}
真常量
#include <iostream>
// C++语言的常量，其实是真常量，C常量还是可以修改值
int main() {
const int number = 100;
// number = 200;
// 我的编译器，编译不通过， 有的编译器，编译通过，但是运行报错（结论：就不能改）
// int * numP = &number;
// *numP = 10000;
printf("%d\n", number);
return 0;
}
引用（引用的赋值或者传递相当于指针取了个别名，不管如何操作这个别名，操作的还是这个指针）
#include <iostream>
using namespace std;
// 互换两个数
// 指针取地址 互换 C语言第一节课的内容
// 接收number1/number2的地址，取改地址的值，来完成的互换
void numberChange(int * number1, int * number2) {
int temp = 0;
temp = *number1;
*number1 = *number2;
*number2 = temp;
}
// C++提倡的引用
void numberChange2(int & number1, int & number2) {
// 如果不采用引用，main numberChange2 内存地址是不一样的
// 如果采用引用，main numberChange2 内存地址是一样的，为什么呢？
cout << "numberChange2 " << "n1地址：" << &number1 << " , n2地址：" << &number2 <<endl;
int temp = 0;
temp = number1;
number1 = number2;
number2 = temp;
}
int main() {
int number1 = 10;
int number2 = 20;
cout << "main " << "n1地址：" << &number1 << " , n2地址：" << &number2 <<endl;
// numberChange(&number1, &number2);
numberChange2(number1, number2);
cout << "n1:" << number1 << " , n2:" << number2 << endl;
cout << endl;
// 引用做实验，来学原理：
// 第一部分，不采用 &
/*int n1 = 999;
int n2 = n1;
cout << &n1 << "---" << &n2 << endl;*/ // 0xffffcbb4---0xffffcbb0
// 第二部分，采用&
int n1 = 999;
int & n2 = n1;
int & n9 = n1;
n2 = 777;
n9 = 9527;
cout << "地址：" << &n1 << "---" << &n2 << endl;
cout << "值：" << n1 << "---" << n2 << endl;
return 0;
}
常量引用
#include <iostream>
#include <string.h>
using namespace std;
// 代码的统一性
typedef struct {
char name[20];
int age;
}Student;
// 常量引用：Student不准你改 == const Student &
// 插入数据库，Student的信息给插入数据库
void insertStudent(const Student & student) {
// 内鬼 卧底
// strcpy(student.name, "李元霸"); 不能这样修改
Student student2 = {"刘奋", 43};
// student = student2; 不能这样修改
// 只读的了，可以安心插入数据库了
cout << student.name << "," << student.age << endl;
}
int main() {
// 用户提交的Student数据
Student student = {"张无忌", 30};
insertStudent(student);
return 0;
}
指针常量 常量指针 常量指针常量
#include <iostream>
#include <string.h>
#include <string.h>
using namespace std;
int main() {
// *strcpy (char *__restrict, const char *__restrict);
// strcpy()
int number = 9;
int number2 = 8;
// 大道至简 一分钟搞定
// 常量指针
const int * numberP1 = &number;
// *numberP1 = 100; // 报错，不允许去修改【常量指针】存放地址所对应的值
// numberP1 = &number2; // OK，允许重新指向【常量指针】存放的地址
// 指针常量
int* const numberP2 = &number;
*numberP2 = 100; // OK，允许去修改【指针常量】存放地址所对应的值
// numberP2 = &number2; // 报错，不允许重新指向【指针常量】存放的地址
// 常量指针常量
const int * const numberP3 = &number;
// *numberP3 = 100; // 报错，不允许去修改【常量指针常量】存放地址所对应的值
// numberP3 = &number2; // 报错，不允许重新指向【常量指针常量】存放的地址
return 0;
}
重载
// C++语言的函数重载 是支持的
#include <iostream>
using namespace std;
// Java构造函数 50个字段，我真正使用的，只有6个
// 建造者设计模式 去解决此问题
// int add(int number1, int number2) = number1 + number2; // 这个是KT写法
int add(int number1) {
return number1;
}
int add(int number1, int number2) {
return number1 + number2;
}
// C++重载 == Java重载
int add(int number1, int number2, int number3) {
return number1 + number2 + number3;
}
// 函数重载 二义性
// 自己做实验
// 默认行参赋值， // KT也有默认行参赋值 优先寻找默认行参赋值的函数， 跟顺序无关
int add(double n1 = 100, int n2 = 200, int n3 = 300, int n4 = 400, bool isOK = 0) {
return 0;
}
// 后面：函数顺序的问题？
int main() {
add(999);
add(999, 777);
add(100, 200, 888);
return 0;
}
系统源码里面大量的写法 [特殊写法，意义何在]
#include <iostream>
using namespace std;
// 前期先抽象出现，我后面再升级
// 后面你可以扩展
void JNIMethod(double, double, int, int) {
}
// 上层日志
// 我前期的时候，没有考虑好，为了防止扩展功能，你必须传递一个int类型参数
// 0：服务器同步， 1：友萌服务器同步 2：服务器同步+友萌服务器同步
void uploadLogToEngine(char * logText, int mode) {
// 普通上传日志
// 半年过后，我再来补这个功能
if (mode) {
} else if (mode == 1) {
}
}
int main(void) {
// 前面一个月开发功能的时候
uploadLogToEngine("xxxxx", 0); // 300出地方调用
uploadLogToEngine("xxxxx", 2); // 600出地方调用
uploadLogToEngine("xxxxx", 1); // 400出地方调用
JNIMethod(9.0 ,9.9, 1, 2);
return 0;
}
C++面向对象
#include "Student.h"
int main() {
// 规范写法：要有 头文件.h .hpp -- 实现文件 .c cpp
std::cout << 1 << std::endl;
// TODO ======= 下面是栈空间
Student student1; // 栈区开辟空间的
// 赋值
student1.setAge(99);
student1.setName("李连杰");
cout << "name:" << student1.getName() << " ,age:" << student1.getAge() << endl;
// TODO ======= 下面是堆空间
Student * student2 = new Student(); // new/delete
// 赋值
student2->setAge(88);
student2->setName("李元霸");
cout << "name:" << student2->getName() << " ,age:" << student2->getAge() << endl;
if (student2)
delete student2; // 必须手动释放堆空间的对象student2
student2 = NULL; // 指向NULL的地址区域
// free(student2); // 不能这样写，不规范，会被鄙视的
return 0;
// 以后学习C++的时候，可能没有写头文件，是不规范的，只是为了讲课
// 真实开发过程中，必须规范来：
// 正规的流程：【xxx.so（C/Cpp的实现代码） 用户拿到xxx.so】， 头文件
} // main函数弹栈后，会释放栈成员 student1
bool 非零即true
#include <iostream>
using namespace std; // std 是系统的，必须这样叫
int main() {
// bool isOK = 1; // !0 就true
// bool isOK = -8891; // !0 就true
// bool isOK = 4359; // !0 就true
bool isOK = 0; // 0 就false
// 只有两个类型： !0 0
// 和前面的C一模一样
if (isOK) {
cout << "真" << endl;
} else {
cout << "假" << endl;
}
// ==========================
bool isRun = true;
isRun = false;
cout << isRun << endl; // true==1, false=0
return 0;
}
网友评论