0
点赞
收藏
分享

微信扫一扫

结合 Spring Boot Native 和 Spring Boot 构建高性能服务器架构

Sophia的玲珑阁 2024-11-06 阅读 9

c++基础入门

#include <iostream>
#include <cmath>
#include <unistd.h>	// 总结:按照书写依次往下,先看 iostream 再看 cxxx 最后 xxx.h

using namespace std;	// 本质:自定义作用域,作用域就在该命名空间内部。一个命名空间内部名字不重名就可以,不同命名空间可以相同

int main()
{
    // 输出
    cout << "abc" << 100 << endl;	// cerr << "abc";  不带缓冲区输出,无需换行缓冲
    
    // 输入
    int n;
    cin >> n >> m;	// endl 换行符
    
    return 0;
}
// std 看作班级,std::cout 就是告知某班某成员,避免反复书写,直接写在程序开头

c++编译

g++ old_name -o new_name

字符串

string 会自动分配扩大内存空间

    
// 空间扩展演示
string s14;
cin >> s14;	// 输入123456789
cout << s14.capacity() << endl;	// 空间大小  15	默认空间大小就是15,若后续超出范围会自动扩展
cout << s14.length() << endl;	// 实际大小  9


// 输入
sreint s;
cin >> s;
cout << s << endl;
   

// 赋值
string s1 = "abcd";


// 复制
string s2;
s2 = s1;


// 拼接
string s3;
s3 = "xyz" + s1;
s3 += "123";


// 比对
if(s1 ==  "abcd")
    cout << s1 << "== abcd" << endl;
if(s1 > "aBcd")
    cout << "yes" << endl;	// 挨个按照 ascoll 码值来对比


// 展示循环打印字符串
string s[10] = "abcdef";
for(int i = 0; i < s.length; i++)
{
    cout << s[i];
}
cout << endl;


// 删除
string s("");
cout << s << endl; 
s.erase(4,5);	// 从第四个位置开始删除,删除5个索引
cout << s << endl;
  

// 查找
cout << s.find("all", 30, 100) << endl;	// 从下标索引30开始向后查找,一直查到100
cout << s.find_last_of("So") << endl;	// 从后往前查询


// 替换
string s("123456789");
cout << s.replace(5, 5, "A") << endl;	// 将下表为5的位置开始,替换后面5个为A

引用

概念:给一个已有的对象(变量)取别名

& 号放在定义语句当中就是取别名

// 变量
int a = 100;
int &b = a;	// 让 a 的别名叫做 b

// 数组
int c[10] = {1,2,3};
int (&d)[10] = c;

// 指针
int *p = &a;	// 此时是取地址,不同于取别名
int *(&q) = p;

注意:
    1、不可以给常量取引用,int &r = 100;  常量是匿名的
    2、引用必须同时定义与赋值
    3、相较于指针更加快速高效

// 例如:交换两个数的值
void swap(&a, &b)
{
    int temp;
    
    temp = a;
    a = b;
    b = temp;
}
int main()
{
    int a = 1, b = 2;
    
    swap(a, b);
    
    cout << a << b << endl;
    
    return 0;
}

函数默认参数

void f(int a, float b = 3.14);

void f(int a, float b)
{
    cout << a << endl;
    cout << b << endl;
}

int main()
{
    f(100, 1.23);	// 显式的给 b 传递参数 1.23
    
    f(200);	// b 使用默认值,3.14
}

注意:
    1、为防止二义性,默认值参数只能位于最右边
    2、声明指定默认值,定义不写默认值

函数重载

本质就是同一个函数名有不同的版本。

函数重载时,调用函数是在编译期间就确定了具体的调用对象,因此将函数重载叫做静态联编

可以形成重载的情形(只要满足一个即可):

1、参数个数不同

2、参数类型不同

3、参数顺序不同

3、类方法的const属性

4、普通指针与常目标指针

// 参数个数不同
void f(int a);
void f(int a, int b);

// 参数类型不同
void f(int a);
void f(float b);

// 参数顺序不同
void f(int a, float b);
void f(float a, int b);

// 类方法的 const 属性
class Node
{
    void f(int a);
    void f(int a)const;
};

// 普通指针与常目标指针  查看匹配度
void f(char *p);
void f(const char *p);

不可以形成重载的情形:

1、函数名、函数参数列表完全一致

2、函数返回值类型差异

3、静态函数声明(static

4、const型变量(包括常指针)

// 函数名、函数参数列表完全一致
void f(int a);
void f(int a);

// 函数返回值类型差异
void f(int a);
int f(int a);

// 静态函数声明(static)
void f(int a);
static void f(int a);

// const 型变量(包括常指针)
void f(int *a);
void f(int * const a);

堆内存管理

new:分配堆内存

delete:释放堆内存

int main()
{
    // 分配单个
    int *p = new int;	// 要在堆内存开辟一块新的可以放下 int 类型的空间
    *p1 = 666;
    delete p1;
    
    // 分配多个
    char *k = new char[1000];
    for(int i = 0; i < 1000; i++)
    {
        k[i] = 666;
    }
    delete [] k;
    
    return 0;
}

注意:
相比于 malloc 的区别:(delete 与 free类似于此)
    1、new 会自动调用类的构造函数,而 malloc 不会;

枚举循环

int main()
{
    int a[] = {1,2,3,4,5};
    
    for(int i : a)	// 用 i 来依次取得数组内部数据
    {
        cout << i << endl;
    }
    
    return 0;
}

int main()
{
    list<string> names;
    names.push_back("1");
    names.push_back("2");
    names.push_back("3");
    
    for(string n : names)
        cout << n << endl;	// 将名字全部打印出来,前面的类型对应后面需要打印的元素的类型
    
    return 0;
}

// 若是版本不支持则: g++ old_name -o new_name -std=c++11
举报

相关推荐

0 条评论