C++ 在c+中声明全局变量而不初始化+；

假设我有一个头文件：

class.h

#pragma once
#include <iostream>
#include <string>
using namespace std;

class my_class
{
private:
    string var1;
public:
    my_class(string var1_val) { var1 = var1_val; };
};

---

如何定义变量

f

，以便在

main

中对其进行初始化，同时在

source.cpp

文件中的另一个函数中使用它？

问题中有一些问题。我将试着逐一解决这些问题

---

关于默认构造函数的错误消息就是：您要求实例化该类的一个实例，但您只提供了一种方法：使用

string

参数的构造函数

有两种方法可以“直接”处理：

提供一个默认构造函数，方法是显式地使用它或使

string

参数可选，例如

myu类（string var1\u val={}）

在实例化时提供所述参数：

my_class f{”“}

---

在全局范围中有一个变量“outside”，但在

main（）中初始化。

。。。另外，有几种方法可以解决这个问题（我个人建议，出于各种原因，不要采用这种做法，但这里提供了完整的选项）：

使用指针。将变量声明为

my_class*f{nullptr}或者，更好的是，作为一个智能指针：
std:：unique\u ptr f并在main中将对象实例化为裸指针
f=newmyu类（“字符串”）或智能指针
f=std:：make_unique（“args”）

将该变量局部设置为

main（）

，并将其传递到您需要的任何函数中

---

您还可以考虑使用单例模式，其中有一个工厂函数来管理

f

（在本例中，这是一个可怕的想法，但提供它是为了完整性）：

myu类&获取myu类（字符串s={}）{
静态my_类*mc{nullptr}；
如果（！mc）{mc=new my_class{s}；}/在这个问题中有一些东西混合在一起，我将试着分别解决它们


关于默认构造函数的错误消息就是：您要求实例化该类的一个实例，但您只提供了一种方法：使用
string
参数的构造函数

有两种方法可以“直接”处理：

提供一个默认构造函数，方法是显式地使用它或使
string
参数可选，例如
myu类（string var1\u val={}）
在实例化时提供所述参数：
my_class f{”“}；

在全局范围内有一个变量“outside”，但在
main（）
中初始化。另外，还有一些处理方法（我个人建议，出于各种原因，不要使用这种做法，但这里提供了完整性选项）：

使用指针。将变量声明为
my_class*f{nullptr}；
或者更好地声明为智能指针：
std:：unique_ptr f；
并在main中将对象实例化为裸指针
f=new my_class（“字符串”）
或智能指针
f=std:：make_unique（“args”）
将该变量局部设置为
main（）
，并将其传递到您需要的任何函数中

您还可以考虑使用单例模式，其中有一个工厂函数来管理
f
（在本例中，这是一个可怕的想法，但提供它是为了完整性）：

myu类&获取myu类（字符串s={}）{
静态my_类*mc{nullptr}；
如果（！mc）{mc=new my_class{s}；}/您描述的问题

就像下面的代码运行一样，我得到了：“my_类”：没有合适的默认构造函数可用

是因为您已经声明了另一个带有某些参数的构造函数。在这种情况下，编译器不会生成默认构造函数。您必须自己生成。因此该类应该如下所示：

    class my_class
{
private:
    string var1;
public:
    my_class(){};
    explicit my_class(string var1_val) : 
    var1(var1_val)
    {};
};

好的做法是当您使用一个参数创建构造函数时，将其标记为显式的
。另一个好的做法是在构造函数初始化列表中分配变量

向您描述的问题致意

就像下面的代码运行一样，我得到了：“my_类”：没有合适的默认构造函数可用

是因为您已经声明了另一个带有某些参数的构造函数。在这种情况下，编译器不会生成默认构造函数。您必须自己生成。因此该类应该如下所示：

    class my_class
{
private:
    string var1;
public:
    my_class(){};
    explicit my_class(string var1_val) : 
    var1(var1_val)
    {};
};

好的做法是当您使用一个参数创建构造函数时，将其标记为显式的
。另一个好的做法是在构造函数初始化列表中分配变量

致以最诚挚的问候
就这样做吧

my_class(string var1_val="") { var1 = var1_val; };

提供默认参数&很好。
只是为了让编译器闭嘴。
尽管使用全局对象不是一个好的解决方案。
只需这样做

my_class(string var1_val="") { var1 = var1_val; };

提供默认参数&很好。
只是为了让编译器闭嘴。
尽管使用全局对象不是一个好的解决方案。
这不可能直接实现…全局类实例需要初始化（只有像<代码> int <代码> >或代码>双< /代码>可以被初始化，但只在局部范围内——作为全局的，它们总是被初始化的，并且这种可能的变量不被初始化也是很多人认为C++语言设计错误的原因。至少，它是令人讨厌的bug的来源，并且没有提供真正的优势）

您想要做的可以解释为通常称为“单例模式”的变体…即提供所有模块对类的单个实例的访问

<>这在C++中通常是使用一个函数返回的，该函数返回变量的引用，例如：

------------------------------------------------------------ parms.h
...
struct Parms {
    std::string user_name;
    int user_age;
    static Parms& get();   // Providing access to the singleton
};

-------------------------------------------------------- module1.cpp
#include "parms.h"
...
void foo() {
    // access the singleton
    std::cout << "Hello " << Parms::get().user_name << "\n";
}

---------------------------------------------------------- parms.cpp
#include "parms.h"
...

static Parms* parmsp;

void init_parms(const std::string& user_name, int user_age) {
    // creates the singleton
    parmsp = new Parms{user_name, user_age};
}

Parms& Parms::get() {
    // Provide access to the singleton
    if (!parmsp) {
        throw std::runtime_error("Parameters not yet initialized");
    }
    return *parmsp;
}

---------------------------------------------------------------parms.h
...
结构参数{
std:：字符串用户名；
int用户年龄；
静态参数&